evnty 1.5.3 → 2.1.0

package/build/index.d.ts

@@ -1,23 +1,28 @@
 export type MaybePromise<T> = Promise<T> | PromiseLike<T> | T;
-export interface Unsubscribe {
-    (): void;
+export interface Callback<R = void> {
+    (): MaybePromise<R>;
 }
-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 Result<T, E> {
+    ok: boolean;
+    result: T | E;
 }
-export interface Filter<T extends unknown[]> {
-    (...args: T): MaybePromise<boolean>;
+export interface FilterFunction<T> {
+    (event: T): MaybePromise<boolean>;
 }
-export interface Mapper<T extends unknown[], R> {
-    (...args: T): MaybePromise<R>;
+export interface Predicate<T, P extends T> {
+    (event: T): event is P;
 }
-export interface Reducer<T extends unknown[], R> {
-    (value: R, ...args: T): MaybePromise<R>;
+export type Filter<T, P extends T> = Predicate<T, P> | FilterFunction<T>;
+export interface Mapper<T, R> {
+    (event: T): MaybePromise<R>;
 }
-export type Listeners<T extends unknown[], R> = Listener<T, 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
@@ -28,28 +33,27 @@ 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): () => void;
+    constructor(callback: Callback);
+    pre(callback: Callback): Dismiss;
+    post(callback: Callback): Dismiss;
+    countdown(count: number): Dismiss;
 }
-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 +62,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.
      */
@@ -85,7 +70,7 @@ export declare class Event<T extends unknown[], R = void> extends FunctionExt {
     /**
      * A function that disposes of the event and its listeners.
      */
-    readonly dispose: Dispose;
+    readonly dispose: Callback;
     /**
      * Creates a new event.
      * @example
@@ -95,7 +80,7 @@ export declare class Event<T extends unknown[], R = void> 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.
      */
@@ -129,15 +114,15 @@ export declare class Event<T extends unknown[], R = void> 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.
      */
-    toPromise(): Promise<T>;
+    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
@@ -146,7 +131,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 +142,18 @@ 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 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
@@ -165,7 +162,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 +178,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 +196,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 +226,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 +239,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
  *

package/build/index.js

@@ -8,43 +8,38 @@ export class Dismiss extends FunctionExt {
     constructor(callback){
         super(callback);
     }
-    async after(task) {
-        await task();
-        this();
+    pre(callback) {
+        return new Dismiss(async ()=>{
+            await callback();
+            await this();
+        });
+    }
+    post(callback) {
+        return new Dismiss(async ()=>{
+            await this();
+            await callback();
+        });
     }
-    afterTimes(count) {
-        return ()=>{
+    countdown(count) {
+        return new Dismiss(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)));
 export 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 = ()=>{
+        this.dispose = async ()=>{
             this.clear();
-            dispose?.();
+            await dispose?.();
         };
     }
     get size() {
@@ -68,42 +63,45 @@ export 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);
     }
+    onceAsync() {
+        return new Promise((resolve)=>this.once((event)=>resolve(event)));
+    }
     clear() {
         this.listeners.splice(0);
     }
-    toPromise() {
-        return new Promise((resolve)=>this.once((...args)=>resolve(args)));
-    }
     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;
     }
+    firstAsync(filter) {
+        return this.first(filter).onceAsync();
+    }
     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);
@@ -111,10 +109,10 @@ export 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);
@@ -122,20 +120,26 @@ export 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;
     }
 }
-export const once = (event)=>{
-    return new Promise((resolve)=>event.once((...args)=>resolve(args)));
+export const merge = (...events)=>{
+    const mergedEvent = new Event();
+    events.forEach((event)=>event.on(mergedEvent));
+    return mergedEvent;
 };
-export const createEvent = ()=>{
-    return new Event();
+export const createInterval = (interval)=>{
+    let counter = 0;
+    const intervalEvent = new Event(()=>clearInterval(timerId));
+    const timerId = setInterval(()=>intervalEvent(counter++), interval);
+    return intervalEvent;
 };
+export const createEvent = ()=>new Event();
 export default createEvent;
 
 //# sourceMappingURL=index.js.map

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 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","Function","constructor","func","Object","setPrototypeOf","prototype","Dismiss","callback","after","task","afterTimes","count","eventEmitter","listeners","args","Promise","all","map","listener","Event","merge","events","mergedEvent","forEach","event","on","interval","counter","intervalEvent","clearInterval","timerId","setInterval","dispose","fn","clear","size","length","lacks","indexOf","has","off","index","splice","push","once","oneTimeListener","toPromise","resolve","filter","filteredEvent","first","mapper","mappedEvent","value","reduce","reducer","init","reducedEvent","debounce","timer","clearTimeout","setTimeout","debouncedEvent","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 anonymous event library",
-  "version": "1.5.3",
+  "description": "0-Deps, simple, fast, for browser and node js reactive anonymous event library",
+  "version": "2.1.0",
   "type": "module",
   "types": "build/index.d.ts",
   "main": "build/index.cjs",
@@ -12,16 +12,10 @@
   },
   "files": [
     "build",
-    "src/index.ts"
+    "src/index.ts",
+    "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"
@@ -34,7 +28,13 @@
     "emitter",
     "anonymous",
     "flow",
-    "event-driven"
+    "event-driven",
+    "reactive",
+    "reactivity",
+    "react",
+    "signal",
+    "functional",
+    "stream"
   ],
   "runkitExampleFilename": "src/__tests__/example.js",
   "funding": "https://github.com/sponsors/3axap4eHko",
@@ -49,19 +49,26 @@
   },
   "homepage": "https://github.com/3axap4eHko/evnty#readme",
   "devDependencies": {
-    "@swc/jest": "^0.2.24",
-    "@types/jest": "^29.5.0",
-    "@typescript-eslint/eslint-plugin": "^6.3.0",
-    "@typescript-eslint/parser": "^6.3.0",
-    "eslint": "^8.37.0",
+    "@swc/jest": "^0.2.29",
+    "@types/jest": "^29.5.5",
+    "@types/node": "^20.8.2",
+    "@typescript-eslint/eslint-plugin": "^6.7.4",
+    "@typescript-eslint/parser": "^6.7.4",
+    "eslint": "^8.50.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-import": "^2.28.1",
     "eslint-plugin-prettier": "^5.0.0",
     "husky": "^8.0.3",
     "inop": "^0.4.2",
-    "jest": "^29.5.0",
-    "prettier": "^3.0.1",
-    "typescript": "^5.0.3"
+    "jest": "^29.7.0",
+    "prettier": "^3.0.3",
+    "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/__tests__/example.js

@@ -0,0 +1,45 @@
+const { createEvent, Event, once } = require('evnty');
+
+// Creates a click event
+const clickEvent = createEvent();
+const handleClick = ({ button }) => console.log('Clicked button is', button);
+const unsubscribeClick = clickEvent.on(handleClick);
+
+// Creates a key press event
+const keyPressEvent = createEvent();
+const handleKeyPress = ({ key }) => console.log('Key pressed', key);
+const unsubscribeKeyPress = keyPressEvent.on(handleKeyPress);
+
+// Merges click and key press events into input event
+const handleInput = (input) => console.log('Input', input);;
+const inputEvent = Event.merge(clickEvent, keyPressEvent);
+inputEvent.on(handleInput);
+
+// Filters a click event to only include left-click events.
+const handleLeftClick = () => console.log('Left button is clicked');
+const leftClickEvent = clickEvent.filter(({ button }) => button === 'left');
+leftClickEvent.on(handleLeftClick);
+
+// Will press Enter after one second
+setTimeout(keyPressEvent, 1000, { key: 'Enter' });
+// Waits once the first Enter key press event occurs
+await once(keyPressEvent.first(({ key }) => key === 'Enter'));
+
+keyPressEvent({ key: 'W' });
+keyPressEvent({ key: 'A' });
+keyPressEvent({ key: 'S' });
+keyPressEvent({ key: 'D' });
+
+clickEvent({ button: 'right' });
+clickEvent({ button: 'left' });
+clickEvent({ button: 'middle' });
+
+// Unsubscribe click listener
+unsubscribeClick();
+// It does not log anything because of click listener is unsubscribed
+leftClickEvent.off(handleLeftClick);
+
+// Unsubscribe key press listener once first Esc key press occur
+unsubscribeKeyPress.after(() => once(keyPressEvent.first(({ key }) => key === 'Esc')));
+// Press Esc to unsubscribe key press listener
+keyPressEvent({ key: 'Esc' });