evnty 1.5.2 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # Evnty
 
-0-Deps, simple, fast, for browser and node js anonymous event library.
+0-Deps, simple, fast, for browser and node js reactive anonymous event library.
 
 [![Coverage Status][codecov-image]][codecov-url]
 [![Github Build Status][github-image]][github-url]
@@ -10,31 +10,48 @@
 
 ## Table of Contents
 
+- [Motivation](#motivation)
 - [Features](#features)
 - [Platform Support](#platform-support)
 - [Installing](#installing)
+- [Usage](#usage)
+  - [createEvent](#createevent)
+  - [filter](#filter)
+  - [map](#map)
+  - [reduce](#reduce)
+  - [debounce](#debounce)
+  - [merge](#merge)
+  - [createInterval](#createInterval)
 - [Examples](#examples)
-- [Roadmap](#roadmap)
+- [Migration](#migration)
 - [License](#license)
 
+## Motivation
+
+In traditional event handling in TypeScript, events are often represented as strings, and there's no easy way to apply functional transformations like filtering or mapping directly on the event data. This approach lacks type safety, and chaining operations require additional boilerplate, making the code verbose and less maintainable.
+
+The proposed library introduces a robust `Event` abstraction that encapsulates event data and provides a suite of functional methods like `map`, `filter`, `reduce`, `debounce`, etc., allowing for a more declarative and type-safe approach to event handling. This design facilitates method chaining and composition, making the code more readable and maintainable. For instance, it allows developers to create new events by transforming or filtering existing ones, thus promoting code reusability and modularity.
+
+#### Benefits:
+
+- Type Safety: The Event abstraction enforces type safety, helping catch potential errors at compile-time.
+- Method Chaining: Functional methods can be chained together to form complex event handling logic with less code.
+- Event Composition: Events can be merged, filtered, or transformed to create new events, promoting code modularity and reusability.
+- Reduced Boilerplate: The library reduces the boilerplate code required to set up complex event handling logic, making the codebase cleaner and easier to manage.
+
 ## Features
 
 - Supports ESM and CommonJS
 - Promises support
-- Full-featured typeScript support
+- Full-featured TypeScript support
 - Browser & Workers environment compatibility
 - Performance eventemitter3/eventemitter2/event-emitter/events/native node/native browser
 
-## Roadmap
-
-- Namespaces/Wildcards
-- Times To Listen (TTL)
-
-## Browser Support
+## Platform Support
 
 | ![NodeJS][node-image] | ![Chrome][chrome-image] | ![Firefox][firefox-image] | ![Safari][safari-image] | ![Opera][opera-image] | ![Edge][edge-image] |
-| ----------------------- | ----------------------- | ------------------------- | ----------------------- | --------------------- | ------------------- |
-| Latest ✔               | Latest ✔               | Latest ✔                 | Latest ✔               | Latest ✔             | Latest ✔           |
+| --------------------- | ----------------------- | ------------------------- | ----------------------- | --------------------- | ------------------- |
+| Latest ✔             | Latest ✔               | Latest ✔                 | Latest ✔               | Latest ✔             | Latest ✔           |
 
 [node-image]: https://raw.github.com/alrra/browser-logos/main/src/node.js/node.js_48x48.png?1
 [chrome-image]: https://raw.github.com/alrra/browser-logos/main/src/chrome/chrome_48x48.png?1
@@ -45,6 +62,12 @@
 
 ## Installing
 
+Using pnpm:
+
+```bash
+pnpm add evnty
+```
+
 Using yarn:
 
 ```bash
@@ -57,20 +80,111 @@ Using npm:
 npm install evnty
 ```
 
+## Usage
+
+### createEvent
+
+Creates a new event instance.
+
+```ts
+import { createEvent, Event } from 'evnty';
+
+type ClickEvent = { x: number; y: number; button: number };
+const clickEvent = createEvent<ClickEvent>();
+
+type KeyPressEvent = { key: string };
+const keyPressEvent = createEvent<KeyPressEvent>();
+
+type ChangeEvent = { target: HTMLInputElement };
+const changeEvent = createEvent<ChangeEvent>();
+document.querySelector('input').addEventListener('change', changeEvent);
+```
+
+### filter
+
+Returns a new event that will only be triggered once the provided filter function returns `true`.
+Supports predicate type guard function and filter function as a more concise variant.
+
+```ts
+import { Predicate } from 'evnty';
+
+type SpacePressEvent = KeyPressEvent & { key: 'Space' };
+type LeftClickEvent = ClickEvent & { button: 1 };
+
+const spacePressPredicate: Predicate<KeyPressEvent, SpacePressEvent> = (keyPressEvent): keyPressEvent is SpacePressEvent => keyPressEvent.key === 'Space';
+// event type is inferred from the predicate function
+const spacePressPredicatedEvent = keyPressEvent.filter(spacePredicate);
+// event type is inferred from the explicitly specified type
+const spacePressFilteredEvent = keyPressEvent.filter<SpacePressEvent>(({ key }) => key === 'Space');
+
+const leftClickPredicate: Predicate<ClickEvent, LeftClickEvent> = (mouseClickEvent): mouseClickEvent is LeftClickEvent => mouseClickEvent.button === 1;
+// event type is inferred from the predicate function
+const leftClickPredicatedEvent = clickEvent.filter(leftClickPredicate);
+// event type is inferred from the explicitly specified type
+const leftClickFilteredEvent = keyPressEvent.filter<LeftClickEvent>(({ button }) => button === 1);
+```
+
+### map
+
+Returns a new event that maps the values of this event using the provided mapper function.
+
+```ts
+const point = { x: 100, y: 100 };
+const distanceClickEvent = clickEvent.map((click) => (click.x - point.x) ** 2 + (click.y - point.y) ** 2);
+const lowerCaseKeyPressEvent = keyPressEvent.map(({ key }) => key.toLowerCase());
+const trimmedChangeEvent = changeEvent.map((event) => event.target.value.trim());
+```
+
+### reduce
+
+Returns a new event that reduces the emitted values using the provided reducer function.
+
+```ts
+const rightClickCountEvent = clickEvent.reduce((result, click) => (click.button === 2 ? result + 1 : result), 0);
+```
+
+### debounce
+
+Returns a new debounced event that will not fire until a certain amount of time has passed since the last time it was triggered.
+
+```ts
+const searchEvent = changeEvent.debounce(500);
+```
+
+### merge
+
+Merges multiple events into a single event.
+
+```ts
+import { merge } from 'evnty';
+
+const inputEvent = merge(clickEvent, keyPressEvent);
+```
+
+### createInterval
+
+Creates an event that triggers at a specified interval.
+
+```ts
+import { createInterval } from 'evnty';
+
+const everySecondEvent = createInterval(1000);
+```
+
 ## Examples
 
 ```js
-import createEvent, { Event, once } from 'evnty';
+import createEvent, { Event } from 'evnty';
 
 // Creates a click event
 type Click = { button: string };
-const clickEvent = createEvent<[Click]>();
+const clickEvent = createEvent<Click>();
 const handleClick = ({ button }: Click) => console.log('Clicked button is', button);
 const unsubscribeClick = clickEvent.on(handleClick);
 
 // Creates a key press event
 type KeyPress = { key: string };
-const keyPressEvent = createEvent<[KeyPress]>();
+const keyPressEvent = createEvent<KeyPress>();
 const handleKeyPress = ({ key }: KeyPress) => console.log('Key pressed', key);
 const unsubscribeKeyPress = keyPressEvent.on(handleKeyPress);
 
@@ -88,7 +202,7 @@ leftClickEvent.on(handleLeftClick);
 // 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'));
+await keyPressEvent.first(({ key }) => key === 'Enter').onceAsync();
 
 keyPressEvent({ key: 'W' });
 keyPressEvent({ key: 'A' });
@@ -105,11 +219,20 @@ unsubscribeClick();
 leftClickEvent.off(handleLeftClick);
 
 // Unsubscribe key press listener once first Esc key press occur
-unsubscribeKeyPress.after(() => once(keyPressEvent.first(({ key }) => key === 'Esc')));
+unsubscribeKeyPress.after(() => keyPressEvent
+  .first(({ key }) => key === 'Esc')
+  .onceAsync()
+);
 // Press Esc to unsubscribe key press listener
 keyPressEvent({ key: 'Esc' });
 ```
 
+## Migration
+
+### From v1 to v2
+
+A breaking change has been made: events no longer accept a list of arguments. Now, each event accepts a single argument, so simply wrap your arguments in an object. This decision was taken to leverage the benefits of predicate type guards.
+
 ## License
 
 License [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

package/build/index.cjs

@@ -18,8 +18,11 @@ _export(exports, {
     Event: function() {
         return Event;
     },
-    once: function() {
-        return once;
+    merge: function() {
+        return merge;
+    },
+    createInterval: function() {
+        return createInterval;
     },
     createEvent: function() {
         return createEvent;
@@ -40,36 +43,23 @@ class Dismiss extends FunctionExt {
     }
     async after(task) {
         await task();
-        this();
+        await this();
     }
     afterTimes(count) {
-        return ()=>{
+        return async ()=>{
             if (!--count) {
-                this();
+                await this();
             }
         };
     }
 }
-const eventEmitter = async (listeners, ...args)=>{
-    return Promise.all(listeners.map((listener)=>listener(...args)));
-};
+const eventEmitter = (listeners, event)=>Promise.all(listeners.map((listener)=>listener(event)));
 class Event extends FunctionExt {
-    static merge(...events) {
-        const mergedEvent = new Event();
-        events.forEach((event)=>event.on(mergedEvent));
-        return mergedEvent;
-    }
-    static interval(interval) {
-        let counter = 0;
-        const intervalEvent = new Event(()=>clearInterval(timerId));
-        const timerId = setInterval(()=>intervalEvent(counter++), interval);
-        return intervalEvent;
-    }
     listeners;
     dispose;
     constructor(dispose){
         const listeners = [];
-        const fn = (...args)=>eventEmitter(listeners, ...args);
+        const fn = (event)=>eventEmitter(listeners, event);
         super(fn);
         this.listeners = listeners;
         this.dispose = ()=>{
@@ -98,42 +88,42 @@ class Event extends FunctionExt {
         return new Dismiss(()=>this.off(listener));
     }
     once(listener) {
-        const oneTimeListener = (...args)=>{
+        const oneTimeListener = (event)=>{
             this.off(oneTimeListener);
-            return listener(...args);
+            return listener(event);
         };
         return this.on(oneTimeListener);
     }
     clear() {
         this.listeners.splice(0);
     }
-    toPromise() {
-        return new Promise((resolve)=>this.once((...args)=>resolve(args)));
+    onceAsync() {
+        return new Promise((resolve)=>this.once((event)=>resolve(event)));
     }
     filter(filter) {
-        const dispose = this.on(async (...args)=>{
-            if (filteredEvent.size > 0 && await filter(...args)) {
-                await filteredEvent(...args);
+        const dispose = this.on(async (event)=>{
+            if (filteredEvent.size > 0 && await filter(event)) {
+                await filteredEvent(event);
             }
         });
         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 dispose = this.on(async (event)=>{
+            if (filteredEvent.size > 0 && await filter(event)) {
+                await dispose();
+                await filteredEvent(event);
             }
         });
         const filteredEvent = new Event(dispose);
         return filteredEvent;
     }
     map(mapper) {
-        const dispose = this.on(async (...args)=>{
+        const dispose = this.on(async (event)=>{
             if (mappedEvent.size > 0) {
-                const value = await mapper(...args);
-                mappedEvent(value);
+                const value = await mapper(event);
+                await mappedEvent(value);
             }
         });
         const mappedEvent = new Event(dispose);
@@ -141,10 +131,10 @@ class Event extends FunctionExt {
     }
     reduce(reducer, init) {
         let value = init;
-        const dispose = this.on(async (...args)=>{
+        const dispose = this.on(async (event)=>{
             if (reducedEvent.size > 0) {
-                value = await reducer(value, ...args);
-                reducedEvent(value);
+                value = await reducer(value, event);
+                await reducedEvent(value);
             }
         });
         const reducedEvent = new Event(dispose);
@@ -152,20 +142,26 @@ class Event extends FunctionExt {
     }
     debounce(interval) {
         let timer;
-        const dispose = this.on((...args)=>{
+        const dispose = this.on((event)=>{
             clearTimeout(timer);
-            timer = setTimeout(()=>debouncedEvent(...args), interval);
+            timer = setTimeout(()=>debouncedEvent(event), interval);
         });
         const debouncedEvent = new Event(dispose);
         return debouncedEvent;
     }
 }
-const once = (event)=>{
-    return new Promise((resolve)=>event.once((...args)=>resolve(args)));
+const merge = (...events)=>{
+    const mergedEvent = new Event();
+    events.forEach((event)=>event.on(mergedEvent));
+    return mergedEvent;
 };
-const createEvent = ()=>{
-    return new Event();
+const createInterval = (interval)=>{
+    let counter = 0;
+    const intervalEvent = new Event(()=>clearInterval(timerId));
+    const timerId = setInterval(()=>intervalEvent(counter++), interval);
+    return intervalEvent;
 };
+const createEvent = ()=>new Event();
 const _default = createEvent;
 
 //# sourceMappingURL=index.cjs.map

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 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> {\n  (...args: T): MaybePromise<R>;\n}\n\nexport interface Reducer<T extends unknown[], R> {\n  (value: R, ...args: T): MaybePromise<R>;\n}\n\nexport type Listeners<T extends unknown[], 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    this();\n  }\n\n  afterTimes(count: number): () => void {\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\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 extends unknown[], R = void> extends FunctionExt {\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   */\n  static 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   */\n  static interval(interval: number): Event<[number], void> {\n    let counter = 0;\n    const intervalEvent = new Event<[number], void>(() => clearInterval(timerId));\n    const timerId: ReturnType<typeof setInterval> = 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   * @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 = (...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(): 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  toPromise(): Promise<T> {\n    return new Promise((resolve) => this.once((...args) => resolve(args)));\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<F extends T>(filter: Filter<T>): Event<F, R> {\n    const dispose = this.on(async (...args: T) => {\n      if (filteredEvent.size > 0 && (await filter(...args))) {\n        await filteredEvent(...(args as F));\n      }\n    });\n    const filteredEvent = new Event<F, 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<F extends T>(filter: Filter<T>): Event<F, R> {\n    const dispose = this.on(async (...args: T) => {\n      if (filteredEvent.size > 0 && (await filter(...args))) {\n        dispose();\n        await filteredEvent(...(args as F));\n      }\n    });\n    const filteredEvent = new Event<F, 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 = unknown>(mapper: Mapper<T, M>): Event<[M], MR> {\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   * 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 = unknown>(reducer: Reducer<T, A>, init: A): Event<[A], AR> {\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   * 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((...args) => {\n      clearTimeout(timer);\n      timer = setTimeout(() => debouncedEvent(...args), interval);\n    });\n    const debouncedEvent = new Event<T, R>(dispose);\n    return debouncedEvent;\n  }\n}\n\n/**\n * Returns a promise that resolves with the arguments passed to the first invocation of the given event.\n * @example\n * const [x, y] = await once(mouseEvent);\n *\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 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 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 * @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> = Filter<EventParameters<E>>;\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","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","debounce","timer","clearTimeout","setTimeout","debouncedEvent"],"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, 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":"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"}

package/build/index.d.ts

@@ -2,22 +2,33 @@ export type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;
 export interface Unsubscribe {
     (): void;
 }
-export interface Listener<T extends unknown[], R = unknown> {
-    (...args: T): MaybePromise<R | void>;
+export interface Listener<T, R = unknown> {
+    (event: T): MaybePromise<R | void>;
 }
 export interface Dispose {
     (): void;
 }
-export interface Filter<T extends unknown[]> {
-    (...args: T): MaybePromise<boolean>;
+export interface Result<T, E> {
+    ok: boolean;
+    result: T | E;
 }
-export interface Mapper<T extends unknown[], R> {
-    (...args: T): MaybePromise<R>;
+export interface Resolver<T, P> {
+    (event: T): Promise<P>;
 }
-export interface Reducer<T extends unknown[], R> {
-    (value: R, ...args: T): MaybePromise<R>;
+export interface FilterFunction<T> {
+    (event: T): MaybePromise<boolean>;
 }
-export type Listeners<T extends unknown[], R> = Listener<T, R>[];
+export interface Predicate<T, P extends T> {
+    (event: T): event is P;
+}
+export type Filter<T, P extends T> = Predicate<T, P> | FilterFunction<T>;
+export interface Mapper<T, R> {
+    (event: T): MaybePromise<R>;
+}
+export interface Reducer<T, R> {
+    (result: R, event: T): MaybePromise<R>;
+}
+export type Listeners<T, R> = 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
@@ -39,17 +50,18 @@ export interface Task {
 export declare class Dismiss extends FunctionExt {
     constructor(callback: Unsubscribe);
     after(task: Task): Promise<void>;
-    afterTimes(count: number): () => void;
+    afterTimes(count: number): () => Promise<void>;
 }
-export interface Event<T extends unknown[], R> {
-    (...args: T): Promise<(R | undefined)[]>;
+type EventType<T> = T extends undefined ? void : T;
+export interface Event<T = unknown, R = void> {
+    (event?: EventType<T>): Promise<(R | undefined)[]>;
 }
 export type EventParameters<T> = T extends Event<infer P, unknown> ? P : never;
-export type EventResult<T> = T extends Event<unknown[], infer R> ? R : never;
-export type AllEventsParameters<T extends Event<unknown[], unknown>[]> = {
+export type EventResult<T> = T extends Event<unknown, infer R> ? R : never;
+export type AllEventsParameters<T extends Event<unknown, unknown>[]> = {
     [K in keyof T]: EventParameters<T[K]>;
 }[number];
-export type AllEventsResults<T extends Event<unknown[], unknown>[]> = {
+export type AllEventsResults<T extends Event<unknown, unknown>[]> = {
     [K in keyof T]: EventResult<T[K]>;
 }[number];
 /**
@@ -58,26 +70,7 @@ export type AllEventsResults<T extends Event<unknown[], unknown>[]> = {
  * @typeParam T - The tuple of arguments that the event takes.
  * @typeParam 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.
-     * @example
-     * const inputEvent = Event.merge(mouseEvent, keyboardEvent);
-     *
-     * @param events - The events to merge.
-     * @returns The merged event.
-     */
-    static merge<Events extends Event<any[], any>[]>(...events: Events): Event<AllEventsParameters<Events>, AllEventsResults<Events>>;
-    /**
-     * Creates an event that triggers at a specified interval.
-     * @example
-     * const tickEvent = Event.interval(1000);
-     * tickEvent.on((tickNumber) => console.log(tickNumber));
-     *
-     * @param interval - The interval at which to trigger the event.
-     * @returns The interval event.
-     */
-    static interval(interval: number): Event<[number], void>;
+export declare class Event<T, R> extends FunctionExt {
     /**
      * The array of listeners for the event.
      */
@@ -137,7 +130,7 @@ export declare class Event<T extends unknown[], R = void> extends FunctionExt {
      * 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.
      */
-    toPromise(): Promise<T>;
+    onceAsync(): Promise<T>;
     /**
      * Returns a new event that only triggers when the provided filter function returns `true`.
      * @example
@@ -146,7 +139,8 @@ export declare class Event<T extends unknown[], R = void> extends FunctionExt {
      * @param filter The filter function to apply to the event.
      * @returns A new event that only triggers when the provided filter function returns `true`.
      */
-    filter<F extends T>(filter: Filter<T>): Event<F, R>;
+    filter<P extends T>(predicate: Predicate<T, P>): Event<P, R>;
+    filter<P extends T>(filter: FilterFunction<T>): Event<P, R>;
     /**
      * Returns a new event that will only be triggered once the provided filter function returns `true`.
      * @example
@@ -156,7 +150,8 @@ export declare class Event<T extends unknown[], R = void> extends FunctionExt {
      * @param filter - The filter function.
      * @returns A new event that will only be triggered once the provided filter function returns `true`.
      */
-    first<F extends T>(filter: Filter<T>): Event<F, R>;
+    first<P extends T>(predicate: Predicate<T, P>): Event<P, R>;
+    first<P extends T>(filter: FilterFunction<T>): Event<P, R>;
     /**
      * Returns a new event that maps the values of this event using the provided mapper function.
      * @example
@@ -165,7 +160,7 @@ export declare class Event<T extends unknown[], R = void> extends FunctionExt {
      * @param mapper A function that maps the values of this event to a new value.
      * @returns A new event that emits the mapped values.
      */
-    map<M, MR = unknown>(mapper: Mapper<T, M>): Event<[M], MR>;
+    map<M, MR = R>(mapper: Mapper<T, M>): Event<M, MR>;
     /**
      * Returns a new event that reduces the emitted values using the provided reducer function.
      * @example
@@ -181,7 +176,7 @@ export declare class Event<T extends unknown[], R = void> extends FunctionExt {
      * @param {A} init The initial value of the accumulated value.
      * @returns {Event<[A], AR>} A new `Event` that emits the reduced value.
      */
-    reduce<A, AR = unknown>(reducer: Reducer<T, A>, init: A): Event<[A], AR>;
+    reduce<A, AR = R>(reducer: Reducer<T, A>, init: A): Event<A, AR>;
     /**
      * Returns a new debounced event that will not fire until a certain amount of time has passed
      * since the last time it was triggered.
@@ -199,14 +194,24 @@ export declare class Event<T extends unknown[], R = void> extends FunctionExt {
     debounce(interval: number): Event<T, R>;
 }
 /**
- * Returns a promise that resolves with the arguments passed to the first invocation of the given event.
+ * Merges multiple events into a single event.
  * @example
- * const [x, y] = await once(mouseEvent);
+ * const inputEvent = Event.merge(mouseEvent, keyboardEvent);
  *
- * @param event The event to listen for.
- * @returns A promise that resolves with the arguments passed to the first invocation of the given event.
+ * @param events - The events to merge.
+ * @returns The merged event.
  */
-export declare const once: <T extends unknown[], R = void>(event: Event<T, R>) => Promise<T>;
+export declare const merge: <Events extends Event<any, any>[]>(...events: Events) => Event<AllEventsParameters<Events>, AllEventsResults<Events>>;
+/**
+ * Creates an event that triggers at a specified interval.
+ * @example
+ * const tickEvent = Event.interval(1000);
+ * tickEvent.on((tickNumber) => console.log(tickNumber));
+ *
+ * @param interval - The interval at which to trigger the event.
+ * @returns The interval event.
+ */
+export declare const createInterval: <R = void>(interval: number) => Event<number, R>;
 /**
  * Creates a new event instance.
  *
@@ -219,7 +224,7 @@ export declare const once: <T extends unknown[], R = void>(event: Event<T, R>) =
  * myEvent.on((str: string) => str.length);
  * await myEvent('hello'); // [5]
  */
-export declare const createEvent: <T extends unknown[], R = void>() => Event<T, R>;
+export declare const createEvent: <T, R = void>() => Event<T, R>;
 export default createEvent;
 /**
  * A type helper that extracts the event listener type
@@ -232,7 +237,13 @@ export type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R>
  *
  * @typeParam E The event type to filter.
  */
-export type EventFilter<E> = Filter<EventParameters<E>>;
+export type EventFilter<E> = FilterFunction<EventParameters<E>>;
+/**
+ * A type helper that extracts the event predicate type
+ *
+ * @typeParam E The event type to predicate.
+ */
+export type EventPredicate<E, P extends EventParameters<E>> = Predicate<EventParameters<E>, P>;
 /**
  * A type helper that extracts the event mapper type
  *