evnty 5.0.0 → 5.1.0

package/build/dispatch-result.js

@@ -0,0 +1,127 @@
+import { isThenable, noop } from "./utils.js";
+const ERR_BRAND = Symbol.for('evnty.ResultError');
+function ResultError(error) {
+    this.error = error;
+}
+ResultError.prototype[ERR_BRAND] = true;
+export function err(error) {
+    return new ResultError(error);
+}
+export function isErr(result) {
+    return typeof result === 'object' && result !== null && result[ERR_BRAND] === true;
+}
+export function isOk(result) {
+    return typeof result !== 'object' || result === null || !result[ERR_BRAND];
+}
+export function unwrap(results) {
+    const len = results.length;
+    const unwrapped = new Array(len);
+    for(let i = 0; i < len; i++){
+        const r = results[i];
+        unwrapped[i] = isErr(r) ? Promise.reject(r.error) : r;
+    }
+    return unwrapped;
+}
+async function resolveMaybePromises(items, asyncIndices) {
+    const pending = new Array(asyncIndices.length);
+    for(let j = 0; j < asyncIndices.length; j++){
+        pending[j] = items[asyncIndices[j]];
+    }
+    const resolved = await Promise.all(pending);
+    for(let j = 0; j < asyncIndices.length; j++){
+        items[asyncIndices[j]] = resolved[j];
+    }
+    return items;
+}
+function resolveAll(results) {
+    const len = results.length;
+    if (len === 0) return results;
+    let firstError;
+    let hasError = false;
+    let asyncIndices = null;
+    for(let i = 0; i < len; i++){
+        const r = results[i];
+        if (isErr(r)) {
+            if (!hasError) {
+                hasError = true;
+                firstError = r.error;
+            }
+        } else try {
+            if (isThenable(r)) (asyncIndices ??= []).push(i);
+        } catch (e) {
+            if (!hasError) {
+                hasError = true;
+                firstError = e;
+            }
+        }
+    }
+    if (hasError) {
+        if (asyncIndices !== null) {
+            for(let j = 0; j < asyncIndices.length; j++){
+                results[asyncIndices[j]].then(noop, noop);
+            }
+        }
+        return Promise.reject(firstError);
+    }
+    if (asyncIndices === null) return results;
+    return resolveMaybePromises(results, asyncIndices);
+}
+function settleAll(results) {
+    const len = results.length;
+    if (len === 0) return [];
+    let asyncIndices = null;
+    const settled = new Array(len);
+    for(let i = 0; i < len; i++){
+        const r = results[i];
+        if (isErr(r)) {
+            settled[i] = {
+                status: 'rejected',
+                reason: r.error
+            };
+        } else try {
+            if (isThenable(r)) {
+                const wrapped = r.then((value)=>({
+                        status: 'fulfilled',
+                        value
+                    }), (reason)=>({
+                        status: 'rejected',
+                        reason
+                    }));
+                (asyncIndices ??= []).push(i);
+                settled[i] = wrapped;
+            } else {
+                settled[i] = {
+                    status: 'fulfilled',
+                    value: r
+                };
+            }
+        } catch (e) {
+            settled[i] = {
+                status: 'rejected',
+                reason: e
+            };
+        }
+    }
+    if (asyncIndices === null) return settled;
+    return resolveMaybePromises(settled, asyncIndices);
+}
+export class DispatchResult {
+    #results;
+    [Symbol.toStringTag] = 'DispatchResult';
+    constructor(results){
+        this.#results = results;
+    }
+    then(onfulfilled, onrejected) {
+        const resolved = this.all();
+        if (resolved instanceof Promise) return resolved.then(onfulfilled, onrejected);
+        return Promise.resolve(resolved).then(onfulfilled, onrejected);
+    }
+    all() {
+        return resolveAll(this.#results);
+    }
+    settled() {
+        return settleAll(this.#results);
+    }
+}
+
+//# sourceMappingURL=dispatch-result.js.map

package/build/dispatch-result.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dispatch-result.ts"],"sourcesContent":["import { Fn, MaybePromise } from './types.js';\nimport { isThenable, noop } from './utils.js';\n\nconst ERR_BRAND = Symbol.for('evnty.ResultError');\n\n/**\n * @internal\n */\nexport interface ResultError<E = unknown> {\n  readonly error: E;\n  readonly [ERR_BRAND]: true;\n}\n\nfunction ResultError<E>(this: ResultError<E>, error: E): void {\n  (this as { error: E }).error = error;\n}\n(ResultError.prototype as { [ERR_BRAND]: true })[ERR_BRAND] = true;\n\n/**\n * @internal\n */\nexport function err<E>(error: E): ResultError<E> {\n  return new (ResultError as unknown as new (error: E) => ResultError<E>)(error);\n}\n\n/**\n * @internal\n */\nexport function isErr(result: unknown): result is ResultError<unknown> {\n  return typeof result === 'object' && result !== null && (result as Record<symbol, boolean>)[ERR_BRAND] === true;\n}\n\n/**\n * @internal\n */\nexport function isOk(result: unknown): boolean {\n  return typeof result !== 'object' || result === null || !(result as Record<symbol, boolean>)[ERR_BRAND];\n}\n\n/**\n * @internal\n */\nexport type DispatchResultItem<T> = MaybePromise<T> | ResultError;\n\n/**\n * @internal\n */\nexport function unwrap<T>(results: DispatchResultItem<T>[]): MaybePromise<T>[] {\n  const len = results.length;\n  const unwrapped = new Array<MaybePromise<T>>(len);\n  for (let i = 0; i < len; i++) {\n    const r = results[i];\n    unwrapped[i] = isErr(r) ? Promise.reject(r.error) : r;\n  }\n  return unwrapped;\n}\n\nasync function resolveMaybePromises<T>(items: MaybePromise<T>[], asyncIndices: number[]): Promise<T[]> {\n  const pending = new Array<PromiseLike<T>>(asyncIndices.length);\n  for (let j = 0; j < asyncIndices.length; j++) {\n    pending[j] = items[asyncIndices[j]] as PromiseLike<T>;\n  }\n  const resolved = await Promise.all(pending);\n  for (let j = 0; j < asyncIndices.length; j++) {\n    items[asyncIndices[j]] = resolved[j];\n  }\n  return items as T[];\n}\n\nfunction resolveAll<T>(results: DispatchResultItem<T>[]): T[] | Promise<T[]> {\n  const len = results.length;\n  if (len === 0) return results as T[];\n\n  let firstError: unknown;\n  let hasError = false;\n  let asyncIndices: number[] | null = null;\n\n  for (let i = 0; i < len; i++) {\n    const r = results[i];\n    if (isErr(r)) {\n      if (!hasError) {\n        hasError = true;\n        firstError = r.error;\n      }\n    } else\n      try {\n        if (isThenable(r)) (asyncIndices ??= []).push(i);\n      } catch (e) {\n        if (!hasError) {\n          hasError = true;\n          firstError = e;\n        }\n      }\n  }\n\n  if (hasError) {\n    if (asyncIndices !== null) {\n      for (let j = 0; j < asyncIndices.length; j++) {\n        (results[asyncIndices[j]] as PromiseLike<T>).then(noop, noop);\n      }\n    }\n    return Promise.reject(firstError);\n  }\n  if (asyncIndices === null) return results as T[];\n\n  return resolveMaybePromises(results as MaybePromise<T>[], asyncIndices);\n}\n\nfunction settleAll<T>(results: DispatchResultItem<T>[]): PromiseSettledResult<T>[] | Promise<PromiseSettledResult<T>[]> {\n  const len = results.length;\n  if (len === 0) return [] as PromiseSettledResult<T>[];\n\n  let asyncIndices: number[] | null = null;\n  const settled = new Array<MaybePromise<PromiseSettledResult<T>>>(len);\n\n  for (let i = 0; i < len; i++) {\n    const r = results[i];\n    if (isErr(r)) {\n      settled[i] = { status: 'rejected', reason: r.error };\n    } else\n      try {\n        if (isThenable(r)) {\n          const wrapped = r.then(\n            (value: T): PromiseFulfilledResult<T> => ({ status: 'fulfilled', value }),\n            (reason: unknown): PromiseRejectedResult => ({ status: 'rejected', reason }),\n          );\n          (asyncIndices ??= []).push(i);\n          settled[i] = wrapped;\n        } else {\n          settled[i] = { status: 'fulfilled', value: r };\n        }\n      } catch (e) {\n        settled[i] = { status: 'rejected', reason: e };\n      }\n  }\n\n  if (asyncIndices === null) return settled as PromiseSettledResult<T>[];\n\n  return resolveMaybePromises(settled, asyncIndices);\n}\n\n/**\n * Wraps an array of values or promises (typically listener results) and provides batch resolution.\n *\n * @template T\n */\nexport class DispatchResult<T> implements PromiseLike<T[]> {\n  #results: DispatchResultItem<T>[];\n\n  readonly [Symbol.toStringTag] = 'DispatchResult';\n\n  constructor(results: DispatchResultItem<T>[]) {\n    this.#results = results;\n  }\n\n  then<TResult1 = T, TResult2 = never>(\n    onfulfilled?: Fn<[T[]], MaybePromise<TResult1>> | null,\n    onrejected?: Fn<[any], MaybePromise<TResult2>> | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    const resolved = this.all();\n    if (resolved instanceof Promise) return resolved.then(onfulfilled, onrejected);\n    return Promise.resolve(resolved).then(onfulfilled, onrejected);\n  }\n\n  /**\n   * Resolves all listener results, rejecting if any promise rejects or any ResultError exists.\n   */\n  all(): T[] | Promise<T[]> {\n    return resolveAll(this.#results);\n  }\n\n  /**\n   * Waits for all listener results to settle, regardless of fulfillment or rejection.\n   */\n  settled(): PromiseSettledResult<T>[] | Promise<PromiseSettledResult<T>[]> {\n    return settleAll(this.#results);\n  }\n}\n"],"names":["isThenable","noop","ERR_BRAND","Symbol","for","ResultError","error","prototype","err","isErr","result","isOk","unwrap","results","len","length","unwrapped","Array","i","r","Promise","reject","resolveMaybePromises","items","asyncIndices","pending","j","resolved","all","resolveAll","firstError","hasError","push","e","then","settleAll","settled","status","reason","wrapped","value","DispatchResult","toStringTag","onfulfilled","onrejected","resolve"],"mappings":"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"}

package/build/event.cjs

@@ -12,11 +12,8 @@ _export(exports, {
     get Event () {
         return Event;
     },
-    get EventResult () {
-        return EventResult;
-    },
-    get Unsubscribe () {
-        return Unsubscribe;
+    get EventIterator () {
+        return EventIterator;
     },
     get createEvent () {
         return createEvent;
@@ -31,165 +28,133 @@ _export(exports, {
         return merge;
     }
 });
-const _fastds = require("fastds");
-const _typescjs = require("./types.cjs");
-const _callablecjs = require("./callable.cjs");
-const _sequencecjs = require("./sequence.cjs");
-class Unsubscribe extends _callablecjs.Callable {
-    _done = false;
-    constructor(callback){
-        super(async ()=>{
-            this._done = true;
-            await callback();
-        });
-    }
-    get done() {
-        return this._done;
-    }
-    pre(callback) {
-        return new Unsubscribe(async ()=>{
-            await callback();
-            await this();
-        });
-    }
-    post(callback) {
-        return new Unsubscribe(async ()=>{
-            await this();
-            await callback();
-        });
-    }
-    countdown(count) {
-        return new Unsubscribe(async ()=>{
-            if (!--count) {
-                await this();
-            }
-        });
-    }
-}
-class EventResult {
-    #results;
-    [Symbol.toStringTag] = 'EventResult';
-    constructor(results){
-        this.#results = results;
+const _asynccjs = require("./async.cjs");
+const _signalcjs = require("./signal.cjs");
+const _listenerregistrycjs = require("./listener-registry.cjs");
+const _dispatchresultcjs = require("./dispatch-result.cjs");
+class EventIterator {
+    #signal;
+    constructor(signal){
+        this.#signal = signal;
     }
-    then(onfulfilled, onrejected) {
-        return this.all().then(onfulfilled, onrejected);
-    }
-    all() {
-        return Promise.all(this.#results);
+    async next() {
+        try {
+            const value = await this.#signal.receive();
+            return {
+                value,
+                done: false
+            };
+        } catch  {
+            return {
+                value: undefined,
+                done: true
+            };
+        }
     }
-    settled() {
-        return Promise.allSettled(this.#results);
+    async return() {
+        return {
+            value: undefined,
+            done: true
+        };
     }
 }
-class Event extends _callablecjs.CallableAsyncIterator {
-    listeners;
-    hooks = new _fastds.RingBuffer();
-    _disposed = false;
-    dispose;
+class Event {
+    #listeners = new _listenerregistrycjs.ListenerRegistry();
+    #signal = new _signalcjs.Signal();
+    #disposer;
+    #onDispose;
+    #sink;
     [Symbol.toStringTag] = 'Event';
-    constructor(dispose){
-        const listeners = new _fastds.RingBuffer();
-        super((value)=>{
-            const results = listeners.toArray().map(async (listener)=>listener(await value));
-            return new EventResult(results);
-        });
-        this.listeners = listeners;
-        this.dispose = ()=>{
-            this._disposed = true;
-            void this.clear();
-            void dispose?.();
-        };
+    constructor(onDispose){
+        this.#onDispose = onDispose;
+        this.#disposer = new _asynccjs.Disposer(this);
+    }
+    get sink() {
+        return this.#sink ??= this.emit.bind(this);
+    }
+    handleEvent(event) {
+        this.emit(event);
     }
     get size() {
-        return this.listeners.length;
+        return this.#listeners.size;
     }
-    get disposed() {
-        return this._disposed;
+    emit(value) {
+        this.#signal.emit(value);
+        return new _dispatchresultcjs.DispatchResult(this.#listeners.dispatch(value));
     }
     lacks(listener) {
-        return !this.listeners.has(listener);
+        return !this.#listeners.has(listener);
     }
     has(listener) {
-        return this.listeners.has(listener);
+        return this.#listeners.has(listener);
     }
     off(listener) {
-        if (this.listeners.compact((l)=>l !== listener) && this.hooks.length) {
-            [
-                ...this.hooks
-            ].forEach((hook)=>hook(listener, _typescjs.HookType.Remove));
-        }
+        this.#listeners.off(listener);
         return this;
     }
     on(listener) {
-        this.listeners.push(listener);
-        if (this.hooks.length) {
-            [
-                ...this.hooks
-            ].forEach((hook)=>hook(listener, _typescjs.HookType.Add));
-        }
-        return new Unsubscribe(()=>{
-            void this.off(listener);
-        });
+        this.#listeners.on(listener);
+        return ()=>void this.off(listener);
     }
     once(listener) {
-        const oneTimeListener = (event)=>{
-            void this.off(oneTimeListener);
-            return listener(event);
-        };
-        return this.on(oneTimeListener);
+        this.#listeners.once(listener);
+        return ()=>void this.off(listener);
     }
     clear() {
-        this.listeners.clear();
-        if (this.hooks.length) {
-            [
-                ...this.hooks
-            ].forEach((hook)=>hook(undefined, _typescjs.HookType.Remove));
-        }
+        this.#listeners.clear();
         return this;
     }
-    async next() {
-        const { promise, resolve } = Promise.withResolvers();
-        this.listeners.push(resolve);
-        return promise.finally(()=>{
-            this.listeners.removeFirst(resolve);
-        });
+    receive() {
+        return this.#signal.receive();
+    }
+    then(onfulfilled, onrejected) {
+        return this.receive().then(onfulfilled, onrejected);
     }
-    async settle() {
-        return await Promise.allSettled([
-            this.next()
-        ]).then(([settled])=>settled);
+    catch(onrejected) {
+        return this.receive().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.receive().finally(onfinally);
+    }
+    settle() {
+        return this.receive().then((value)=>({
+                status: 'fulfilled',
+                value
+            }), (reason)=>({
+                status: 'rejected',
+                reason
+            }));
     }
     [Symbol.asyncIterator]() {
-        const ctrl = new AbortController();
-        const sequence = new _sequencecjs.Sequence(ctrl.signal);
-        const emitEvent = (value)=>{
-            sequence(value);
-        };
-        this.listeners.push(emitEvent);
-        const hook = (target = emitEvent, action)=>{
-            if (target === emitEvent && action === _typescjs.HookType.Remove) {
-                ctrl.abort('done');
-                this.listeners.removeFirst(emitEvent);
-            }
-        };
-        this.hooks.push(hook);
-        return sequence[Symbol.asyncIterator]();
+        return new EventIterator(this.#signal);
+    }
+    dispose() {
+        this[Symbol.dispose]();
     }
     [Symbol.dispose]() {
-        void this.dispose();
+        if (this.#disposer[Symbol.dispose]()) {
+            this.#signal[Symbol.dispose]();
+            this.#listeners.clear();
+            void this.#onDispose?.();
+        }
     }
 }
 const merge = (...events)=>{
-    const mergedEvent = new Event();
-    events.forEach((event)=>event.on(mergedEvent));
+    const mergedEvent = new Event(()=>{
+        for (const event of events){
+            event.off(mergedEvent.sink);
+        }
+    });
+    for (const event of events){
+        event.on(mergedEvent.sink);
+    }
     return mergedEvent;
 };
 const createInterval = (interval)=>{
     let counter = 0;
     const intervalEvent = new Event(()=>clearInterval(timerId));
     const timerId = setInterval(()=>{
-        void intervalEvent(counter++);
+        intervalEvent.emit(counter++);
     }, interval);
     return intervalEvent;
 };

package/build/event.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/event.ts"],"sourcesContent":["import { RingBuffer } from 'fastds';\nimport { MaybePromise, Callback, Listener, HookListener, HookType, FilterFunction, Predicate, Mapper, Reducer } from './types.js';\nimport { Callable, CallableAsyncIterator } from './callable.js';\nimport { Sequence } from './sequence.js';\n\n/**\n * Represents an unsubscribe function that can be called to remove a listener.\n * Provides additional utilities for chaining and conditional unsubscription.\n *\n * @internal\n */\nexport class Unsubscribe extends Callable<[], MaybePromise<void>> {\n  private _done = false;\n\n  constructor(callback: Callback) {\n    super(async () => {\n      this._done = true;\n      await callback();\n    });\n  }\n\n  get done() {\n    return this._done;\n  }\n\n  /**\n   * Creates a new unsubscribe function that executes the given callback before this unsubscribe.\n   *\n   * @param callback - The callback to execute before unsubscribing.\n   * @returns {Unsubscribe} A new Unsubscribe instance.\n   */\n  pre(callback: Callback): Unsubscribe {\n    return new Unsubscribe(async () => {\n      await callback();\n      await this();\n    });\n  }\n\n  /**\n   * Creates a new unsubscribe function that executes the given callback after this unsubscribe.\n   *\n   * @param callback - The callback to execute after unsubscribing.\n   * @returns {Unsubscribe} A new Unsubscribe instance.\n   */\n  post(callback: Callback): Unsubscribe {\n    return new Unsubscribe(async () => {\n      await this();\n      await callback();\n    });\n  }\n\n  /**\n   * Creates a new unsubscribe function that only executes after being called a specified number of times.\n   *\n   * @param count - The number of times this must be called before actually unsubscribing.\n   * @returns {Unsubscribe} A new Unsubscribe instance.\n   */\n  countdown(count: number): Unsubscribe {\n    return new Unsubscribe(async () => {\n      if (!--count) {\n        await this();\n      }\n    });\n  }\n}\n\n/**\n * Wraps an array of values or promises (typically listener results) and provides batch resolution.\n *\n * @template T\n */\nexport class EventResult<T> implements PromiseLike<T[]> {\n  #results: MaybePromise<T>[];\n\n  readonly [Symbol.toStringTag] = 'EventResult';\n  /**\n   * @param results - An array of values or Promise-returning listener calls.\n   */\n  constructor(results: MaybePromise<T>[]) {\n    this.#results = results;\n  }\n\n  then<TResult1 = T, TResult2 = never>(\n    onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    return this.all().then(onfulfilled, onrejected);\n  }\n\n  /**\n   * Resolves all listener results, rejecting if any promise rejects.\n   *\n   * @returns {Promise<T[]>} A promise that fulfills with an array of all resolved values.\n   */\n  all(): Promise<T[]> {\n    return Promise.all(this.#results);\n  }\n  /**\n   * Waits for all listener results to settle, regardless of fulfillment or rejection.\n   *\n   * @returns {Promise<PromiseSettledResult<T>[]>} A promise that fulfills with an array of each result's settled status and value/reason.\n   */\n  settled(): Promise<PromiseSettledResult<T>[]> {\n    return Promise.allSettled(this.#results);\n  }\n}\n\n/**\n * A class representing a multi-listener event emitter with async support.\n * Events allow multiple listeners to react to emitted values, with each listener\n * potentially returning a result. All listeners are called for each emission.\n *\n * Key characteristics:\n * - Multiple listeners - all are called for each emission\n * - Listeners can return values collected in EventResult\n * - Supports async listeners and async iteration\n * - Provides lifecycle hooks for listener management\n * - Memory efficient using RingBuffer for storage\n *\n * Differs from:\n * - Signal: Events have multiple persistent listeners vs Signal's one-time resolution per consumer\n * - Sequence: Events broadcast to all listeners vs Sequence's single consumer queue\n *\n * @template T - The type of value emitted to listeners (event payload)\n * @template R - The return type of listener functions\n */\nexport class Event<T = unknown, R = unknown> extends CallableAsyncIterator<T, EventResult<void | R>> {\n  /**\n   * The ring buffer containing all registered listeners for the event.\n   */\n  private listeners: RingBuffer<Listener<T, R>>;\n\n  /**\n   * The ring buffer containing hook listeners that respond to listener lifecycle events.\n   */\n  private hooks = new RingBuffer<HookListener<T, R>>();\n\n  /**\n   * Flag indicating whether this event has been disposed.\n   */\n  private _disposed = false;\n\n  /**\n   * A function that disposes of the event and its listeners.\n   */\n  readonly dispose: Callback;\n\n  readonly [Symbol.toStringTag] = 'Event';\n  /**\n   * Creates a new event.\n   *\n   * @param dispose - A function to call on the event disposal.\n   *\n   * ```typescript\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   */\n  constructor(dispose?: Callback) {\n    const listeners = new RingBuffer<Listener<T, R>>();\n    super((value: T): EventResult<void | R> => {\n      const results = listeners.toArray().map(async (listener) => listener(await value));\n      return new EventResult(results);\n    });\n\n    this.listeners = listeners;\n\n    this.dispose = () => {\n      this._disposed = true;\n      void this.clear();\n      void dispose?.();\n    };\n  }\n\n  /**\n   * The number of listeners for the event.\n   *\n   * @readonly\n   * @type {number}\n   */\n  get size(): number {\n    return this.listeners.length;\n  }\n\n  /**\n   * Checks if the event has been disposed.\n   *\n   * @returns {boolean} `true` if the event has been disposed; otherwise, `false`.\n   */\n  get disposed(): boolean {\n    return this._disposed;\n  }\n\n  /**\n   * Checks if the given listener is NOT registered for this event.\n   *\n   * @param listener - The listener function to check against the registered listeners.\n   * @returns {boolean} `true` if the listener is not already registered; otherwise, `false`.\n   *\n   * ```typescript\n   * // Check if a listener is not already added\n   * if (event.lacks(myListener)) {\n   *   event.on(myListener);\n   * }\n   * ```\n   */\n  lacks(listener: Listener<T, R>): boolean {\n    return !this.listeners.has(listener);\n  }\n\n  /**\n   * Checks if the given listener is registered for this event.\n   *\n   * @param listener - The listener function to check.\n   * @returns {boolean} `true` if the listener is currently registered; otherwise, `false`.\n   *\n   * ```typescript\n   * // Verify if a listener is registered\n   * if (event.has(myListener)) {\n   *   console.log('Listener is already registered');\n   * }\n   * ```\n   */\n  has(listener: Listener<T, R>): boolean {\n    return this.listeners.has(listener);\n  }\n\n  /**\n   * Removes a specific listener from this event.\n   *\n   * @param listener - The listener to remove.\n   * @returns {this} The event instance, allowing for method chaining.\n   *\n   * ```typescript\n   * // Remove a listener\n   * event.off(myListener);\n   * ```\n   */\n  off(listener: Listener<T, R>): this {\n    if (this.listeners.compact((l) => l !== listener) && this.hooks.length) {\n      [...this.hooks].forEach((hook) => hook(listener, HookType.Remove));\n    }\n    return this;\n  }\n\n  /**\n   * Registers a listener that gets triggered whenever the event is emitted.\n   * This is the primary method for adding event handlers that will react to the event being triggered.\n   *\n   * @param listener - The function to call when the event occurs.\n   * @returns {Unsubscribe} An object that can be used to unsubscribe the listener, ensuring easy cleanup.\n   *\n   * ```typescript\n   * // Add a listener to an event\n   * const unsubscribe = event.on((data) => {\n   *   console.log('Event data:', data);\n   * });\n   * ```\n   */\n  on(listener: Listener<T, R>): Unsubscribe {\n    this.listeners.push(listener);\n    if (this.hooks.length) {\n      [...this.hooks].forEach((hook) => hook(listener, HookType.Add));\n    }\n    return new Unsubscribe(() => {\n      void this.off(listener);\n    });\n  }\n\n  /**\n   * Adds a listener that will be called only once the next time the event is emitted.\n   * This method is useful for one-time notifications or single-trigger scenarios.\n   *\n   * @param listener - The listener to trigger once.\n   * @returns {Unsubscribe} An object that can be used to remove the listener if the event has not yet occurred.\n   *\n   * ```typescript\n   * // Register a one-time listener\n   * const onceUnsubscribe = event.once((data) => {\n   *   console.log('Received data once:', data);\n   * });\n   * ```\n   */\n  once(listener: Listener<T, R>): Unsubscribe {\n    const oneTimeListener = (event: T) => {\n      void this.off(oneTimeListener);\n      return listener(event);\n    };\n    return this.on(oneTimeListener);\n  }\n\n  /**\n   * Removes all listeners from the event, effectively resetting it. This is useful when you need to\n   * cleanly dispose of all event handlers to prevent memory leaks or unwanted triggers after certain conditions.\n   *\n   * @returns {this} The instance of the event, allowing for method chaining.\n   *\n   * ```typescript\n   * const myEvent = new Event();\n   * myEvent.on(data => console.log(data));\n   * myEvent.clear(); // Clears all listeners\n   * ```\n   */\n  clear(): this {\n    this.listeners.clear();\n    if (this.hooks.length) {\n      [...this.hooks].forEach((hook) => hook(undefined, HookType.Remove));\n    }\n    return this;\n  }\n\n  /**\n   * Waits for the next event emission and returns the emitted value.\n   * This method allows the event to be used as a promise that resolves with the next emitted value.\n   *\n   * @returns {Promise<T>} A promise that resolves with the next emitted event value.\n   */\n  async next(): Promise<T> {\n    const { promise, resolve } = Promise.withResolvers<T>();\n    this.listeners.push(resolve);\n\n    return promise.finally(() => {\n      this.listeners.removeFirst(resolve);\n    });\n  }\n\n  /**\n   * Waits for the event to settle, returning a `PromiseSettledResult`.\n   *\n   * @returns {Promise<PromiseSettledResult<T>>} A promise that resolves with the settled result.\n   *\n   * @example\n   * ```typescript\n   * const result = await event.settle();\n   * if (result.status === 'fulfilled') {\n   *   console.log('Event fulfilled with value:', result.value);\n   * } else {\n   *   console.error('Event rejected with reason:', result.reason);\n   * }\n   * ```\n   */\n  async settle(): Promise<PromiseSettledResult<T>> {\n    return await Promise.allSettled([this.next()]).then(([settled]) => settled);\n  }\n\n  /**\n   * Makes this event iterable using `for await...of` loops.\n   *\n   * @returns {AsyncIterator<T>} An async iterator that yields values as they are emitted by this event.\n   *\n   * ```typescript\n   * // Assuming an event that emits numbers\n   * const numberEvent = new Event<number>();\n   * (async () => {\n   *   for await (const num of numberEvent) {\n   *     console.log('Number:', num);\n   *   }\n   * })();\n   * await numberEvent(1);\n   * await numberEvent(2);\n   * await numberEvent(3);\n   * ```\n   */\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    const ctrl = new AbortController();\n    const sequence = new Sequence<T>(ctrl.signal);\n    const emitEvent = (value: T) => {\n      sequence(value);\n    };\n    this.listeners.push(emitEvent);\n    const hook: HookListener<T, R> = (target = emitEvent, action) => {\n      if (target === emitEvent && action === HookType.Remove) {\n        ctrl.abort('done');\n        this.listeners.removeFirst(emitEvent);\n      }\n    };\n    this.hooks.push(hook);\n    return sequence[Symbol.asyncIterator]();\n  }\n\n  [Symbol.dispose](): void {\n    void this.dispose();\n  }\n}\n\nexport type EventParameters<T> = T extends Event<infer P, any> ? P : never;\n\nexport type EventReturn<T> = T extends Event<any, infer R> ? R : never;\n\nexport type AllEventsParameters<T extends Event<any, any>[]> = { [K in keyof T]: EventParameters<T[K]> }[number];\n\nexport type AllEventsResults<T extends Event<any, any>[]> = { [K in keyof T]: EventReturn<T[K]> }[number];\n\n/**\n * Merges multiple events into a single event. This function takes any number of `Event` instances\n * and returns a new `Event` that triggers whenever any of the input events trigger. The parameters\n * and results of the merged event are derived from the input events, providing a flexible way to\n * handle multiple sources of events in a unified manner.\n *\n * @template Events - An array of `Event` instances.\n * @param events - A rest parameter that takes multiple events to be merged.\n * @returns {Event<AllEventsParameters<Events>, AllEventsResults<Events>>} Returns a new `Event` instance\n *           that triggers with the parameters and results of any of the merged input events.\n *\n * ```typescript\n * // Merging mouse and keyboard events into a single event\n * const mouseEvent = createEvent<MouseEvent>();\n * const keyboardEvent = createEvent<KeyboardEvent>();\n * const inputEvent = merge(mouseEvent, keyboardEvent);\n * inputEvent.on(event => console.log('Input event:', event));\n * ```\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 a periodic event that triggers at a specified interval. The event will automatically emit\n * an incrementing counter value each time it triggers, starting from zero. This function is useful\n * for creating time-based triggers within an application, such as updating UI elements, polling,\n * or any other timed operation.\n *\n * @template R - The return type of the event handler function, defaulting to `void`.\n * @param interval - The interval in milliseconds at which the event should trigger.\n * @returns {Event<number, R>} An `Event` instance that triggers at the specified interval,\n *           emitting an incrementing counter value.\n *\n * ```typescript\n * // Creating an interval event that logs a message every second\n * const tickEvent = createInterval(1000);\n * tickEvent.on(tickNumber => console.log('Tick:', tickNumber));\n * ```\n */\nexport const createInterval = <R = unknown>(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(() => {\n    void intervalEvent(counter++);\n  }, interval);\n  return intervalEvent;\n};\n\n/**\n * Creates a new Event instance for multi-listener event handling.\n * This is the primary way to create events in the library.\n *\n * @template T - The type of value emitted to listeners (event payload)\n * @template R - The return type of listener functions (collected in EventResult)\n * @returns {Event<T, R>} A new Event instance ready for listener registration\n *\n * ```typescript\n * // Create an event that accepts a string payload\n * const messageEvent = createEvent<string>();\n * messageEvent.on(msg => console.log('Received:', msg));\n * messageEvent('Hello'); // All listeners receive 'Hello'\n *\n * // Create an event where listeners return values\n * const validateEvent = createEvent<string, boolean>();\n * validateEvent.on(str => str.length > 0);\n * validateEvent.on(str => str.length < 100);\n * const results = await validateEvent('test'); // EventResult with [true, true]\n * ```\n */\nexport const createEvent = <T = unknown, R = unknown>(): Event<T, R> => new Event<T, R>();\n\nexport default createEvent;\n\n/**\n * Extracts the listener function type from an Event type.\n * Useful for type-safe listener definitions.\n *\n * @template E - The Event type to extract the listener type from\n *\n * @example\n * ```typescript\n * type MyEvent = Event<string, boolean>;\n * type MyListener = EventHandler<MyEvent>; // (value: string) => boolean | Promise<boolean>\n * ```\n */\nexport type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;\n\n/**\n * Extracts a filter function type for an Event's parameters.\n * Used for creating type-safe event filters.\n *\n * @template E - The Event type to create a filter for\n */\nexport type EventFilter<E> = FilterFunction<EventParameters<E>>;\n\n/**\n * Extracts a predicate function type for an Event's parameters.\n * Used for type narrowing with event values.\n *\n * @template E - The Event type to create a predicate for\n * @template P - The narrowed type that the predicate validates\n */\nexport type EventPredicate<E, P extends EventParameters<E>> = Predicate<EventParameters<E>, P>;\n\n/**\n * Extracts a mapper function type for transforming Event parameters.\n * Used for creating type-safe event value transformations.\n *\n * @template E - The Event type to create a mapper for\n * @template M - The target type to map event values to\n */\nexport type EventMapper<E, M> = Mapper<EventParameters<E>, M>;\n\n/**\n * Extracts a reducer function type for Event parameters.\n * Used for creating type-safe event value reducers.\n *\n * @template E - The Event type to create a reducer for\n * @template R - The accumulator type for the reduction\n */\nexport type EventReducer<E, R> = Reducer<EventParameters<E>, R>;\n"],"names":["Event","EventResult","Unsubscribe","createEvent","createInterval","merge","Callable","_done","callback","done","pre","post","countdown","count","Symbol","toStringTag","results","then","onfulfilled","onrejected","all","Promise","settled","allSettled","CallableAsyncIterator","listeners","hooks","RingBuffer","_disposed","dispose","value","toArray","map","listener","clear","size","length","disposed","lacks","has","off","compact","l","forEach","hook","HookType","Remove","on","push","Add","once","oneTimeListener","event","undefined","next","promise","resolve","withResolvers","finally","removeFirst","settle","asyncIterator","ctrl","AbortController","sequence","Sequence","signal","emitEvent","target","action","abort","events","mergedEvent","interval","counter","intervalEvent","clearInterval","timerId","setInterval"],"mappings":"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"}
+{"version":3,"sources":["../src/event.ts"],"sourcesContent":["import { Callback, Listener, FilterFunction, Predicate, Mapper, Reducer, Action, Fn, Emitter, MaybePromise, Promiseable } from './types.js';\nimport { Disposer } from './async.js';\nimport { Signal } from './signal.js';\nimport { ListenerRegistry } from './listener-registry.js';\nimport { DispatchResult } from './dispatch-result.js';\n\nexport type Unsubscribe = Action;\n\n/**\n * @internal\n */\nexport class EventIterator<T> implements AsyncIterator<T, void, void> {\n  #signal: Signal<T>;\n\n  constructor(signal: Signal<T>) {\n    this.#signal = signal;\n  }\n\n  async next(): Promise<IteratorResult<T, void>> {\n    try {\n      const value = await this.#signal.receive();\n      return { value, done: false };\n    } catch {\n      return { value: undefined, done: true };\n    }\n  }\n\n  async return(): Promise<IteratorResult<T, void>> {\n    return { value: undefined, done: true };\n  }\n}\n\n/**\n * Multi-listener event emitter with async support.\n * All registered listeners are called for each emission, and their return\n * values are collected in a DispatchResult. Supports async iteration and\n * an `onDispose` callback for cleanup.\n *\n * Differs from:\n * - Signal: Event has persistent listeners; Signal is promise-based (receive per round)\n * - Sequence: Event broadcasts to all listeners; Sequence is a single-consumer queue\n *\n * @template T - The type of value emitted to listeners (event payload)\n * @template R - The return type of listener functions\n */\nexport class Event<T = unknown, R = unknown> implements Emitter<T, DispatchResult<void | R>>, Promiseable<T>, Promise<T>, Disposable, AsyncIterable<T> {\n  #listeners = new ListenerRegistry<[T], R | void>();\n  #signal = new Signal<T>();\n  #disposer: Disposer;\n  #onDispose?: Callback;\n  #sink?: Fn<[T], DispatchResult<void | R>>;\n\n  readonly [Symbol.toStringTag] = 'Event';\n\n  /**\n   * Creates a new event.\n   *\n   * @param onDispose - A function to call on the event disposal.\n   *\n   * @example\n   * ```typescript\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   * clickEvent.emit([10, 20]);\n   * ```\n   */\n  constructor(onDispose?: Callback) {\n    this.#onDispose = onDispose;\n    this.#disposer = new Disposer(this);\n  }\n\n  /**\n   * Returns a bound emit function for use as a callback.\n   * Useful for passing to other APIs that expect a function.\n   *\n   * @example\n   * ```typescript\n   * const event = new Event<string>();\n   * someApi.onMessage(event.sink);\n   * ```\n   */\n  get sink(): Fn<[T], DispatchResult<void | R>> {\n    return (this.#sink ??= this.emit.bind(this));\n  }\n\n  /**\n   * DOM EventListener interface compatibility.\n   * Allows the event to be used directly with addEventListener.\n   */\n  handleEvent(event: T): void {\n    this.emit(event);\n  }\n\n  /**\n   * The number of listeners for the event.\n   */\n  get size(): number {\n    return this.#listeners.size;\n  }\n\n  /**\n   * Emits a value to all registered listeners.\n   * Each listener is called with the value and their return values are collected.\n   *\n   * @param value - The value to emit to all listeners.\n   * @returns A DispatchResult containing all listener return values.\n   *\n   * @example\n   * ```typescript\n   * const event = new Event<string, number>();\n   * event.on(str => str.length);\n   * const result = event.emit('hello');\n   * await result.all(); // [5]\n   * ```\n   */\n  emit(value: T): DispatchResult<void | R> {\n    this.#signal.emit(value);\n    return new DispatchResult(this.#listeners.dispatch(value));\n  }\n\n  /**\n   * Checks if the given listener is NOT registered for this event.\n   *\n   * @param listener - The listener function to check against the registered listeners.\n   * @returns `true` if the listener is not already registered; otherwise, `false`.\n   *\n   * @example\n   * ```typescript\n   * // Check if a listener is not already added\n   * if (event.lacks(myListener)) {\n   *   event.on(myListener);\n   * }\n   * ```\n   */\n  lacks(listener: Listener<T, R>): boolean {\n    return !this.#listeners.has(listener);\n  }\n\n  /**\n   * Checks if the given listener is registered for this event.\n   *\n   * @param listener - The listener function to check.\n   * @returns `true` if the listener is currently registered; otherwise, `false`.\n   *\n   * @example\n   * ```typescript\n   * // Verify if a listener is registered\n   * if (event.has(myListener)) {\n   *   console.log('Listener is already registered');\n   * }\n   * ```\n   */\n  has(listener: Listener<T, R>): boolean {\n    return this.#listeners.has(listener);\n  }\n\n  /**\n   * Removes a specific listener from this event.\n   *\n   * @param listener - The listener to remove.\n   * @returns The event instance for chaining.\n   *\n   * @example\n   * ```typescript\n   * // Remove a listener\n   * event.off(myListener);\n   * ```\n   */\n  off(listener: Listener<T, R>): this {\n    this.#listeners.off(listener);\n    return this;\n  }\n\n  /**\n   * Registers a listener that is called on every emission.\n   *\n   * @param listener - The function to call when the event occurs.\n   * @returns A function that removes this listener when called.\n   *\n   * @example\n   * ```typescript\n   * const unsubscribe = event.on((data) => {\n   *   console.log('Event data:', data);\n   * });\n   * ```\n   */\n  on(listener: Listener<T, R>): Unsubscribe {\n    this.#listeners.on(listener);\n    return () => void this.off(listener);\n  }\n\n  /**\n   * Registers a listener that is called only once on the next emission, then auto-removed.\n   *\n   * @param listener - The listener to trigger once.\n   * @returns A function that removes this listener when called (if it hasn't fired yet).\n   *\n   * @example\n   * ```typescript\n   * const cancel = event.once((data) => {\n   *   console.log('Received data once:', data);\n   * });\n   * ```\n   */\n  once(listener: Listener<T, R>): Unsubscribe {\n    this.#listeners.once(listener);\n    return () => void this.off(listener);\n  }\n\n  /**\n   * Removes all listeners from the event.\n   * Does not dispose the event - new listeners can still be added after clearing.\n   *\n   * @returns The event instance for chaining.\n   */\n  clear(): this {\n    this.#listeners.clear();\n    return this;\n  }\n\n  /**\n   * Waits for the next emission and returns the emitted value.\n   *\n   * @returns A promise that resolves with the next emitted value.\n   */\n  receive(): Promise<T> {\n    return this.#signal.receive();\n  }\n\n  then<OK = T, ERR = never>(onfulfilled?: Fn<[T], MaybePromise<OK>> | null, onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<OK | ERR> {\n    return this.receive().then(onfulfilled, onrejected);\n  }\n\n  catch<ERR = never>(onrejected?: Fn<[unknown], MaybePromise<ERR>> | null): Promise<T | ERR> {\n    return this.receive().catch(onrejected);\n  }\n\n  finally(onfinally?: Action | null): Promise<T> {\n    return this.receive().finally(onfinally);\n  }\n\n  /**\n   * Waits for the next emission via `receive()` and wraps the outcome in a\n   * `PromiseSettledResult` - always resolves, never rejects.\n   *\n   * @returns A promise that resolves with the settled result.\n   *\n   * @example\n   * ```typescript\n   * const result = await event.settle();\n   * if (result.status === 'fulfilled') {\n   *   console.log('Value:', result.value);\n   * } else {\n   *   console.error('Reason:', result.reason);\n   * }\n   * ```\n   */\n  settle(): Promise<PromiseSettledResult<T>> {\n    return this.receive().then(\n      (value) => ({ status: 'fulfilled', value }) as const,\n      (reason: unknown) => ({ status: 'rejected', reason }) as const,\n    );\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T, void, void> {\n    return new EventIterator(this.#signal);\n  }\n\n  dispose(): void {\n    this[Symbol.dispose]();\n  }\n\n  [Symbol.dispose](): void {\n    if (this.#disposer[Symbol.dispose]()) {\n      this.#signal[Symbol.dispose]();\n      this.#listeners.clear();\n      void this.#onDispose?.();\n    }\n  }\n}\n\nexport type EventParameters<T> = T extends Event<infer P, any> ? P : never;\n\nexport type EventReturn<T> = T extends Event<any, infer R> ? R : never;\n\nexport type AllEventsParameters<T extends Event<any, any>[]> = { [K in keyof T]: EventParameters<T[K]> }[number];\n\nexport type AllEventsResults<T extends Event<any, any>[]> = { [K in keyof T]: EventReturn<T[K]> }[number];\n\n/**\n * Merges multiple events into a single event that triggers whenever any source triggers.\n * Disposing the merged event unsubscribes from all sources.\n *\n * @param events - The events to merge.\n * @returns A new Event that forwards emissions from all sources.\n *\n * @example\n * ```typescript\n * const mouseEvent = createEvent<MouseEvent>();\n * const keyboardEvent = createEvent<KeyboardEvent>();\n * const inputEvent = merge(mouseEvent, keyboardEvent);\n * inputEvent.on(event => console.log('Input event:', event));\n * ```\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    for (const event of events) {\n      event.off(mergedEvent.sink);\n    }\n  });\n\n  for (const event of events) {\n    event.on(mergedEvent.sink);\n  }\n  return mergedEvent;\n};\n\n/**\n * Creates a periodic event that emits an incrementing counter (starting from 0) at a fixed interval.\n * Disposing the event clears the interval.\n *\n * @param interval - The interval in milliseconds.\n * @returns An Event that triggers at the specified interval.\n *\n * @example\n * ```typescript\n * const tickEvent = createInterval(1000);\n * tickEvent.on(tickNumber => console.log('Tick:', tickNumber));\n * ```\n */\nexport const createInterval = <R = unknown>(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(() => {\n    intervalEvent.emit(counter++);\n  }, interval);\n  return intervalEvent;\n};\n\n/**\n * Creates a new Event instance for multi-listener event handling.\n *\n * @example\n * ```typescript\n * const messageEvent = createEvent<string>();\n * messageEvent.on(msg => console.log('Received:', msg));\n * messageEvent.emit('Hello'); // All listeners receive 'Hello'\n *\n * // Listeners can return values, collected via DispatchResult\n * const validateEvent = createEvent<string, boolean>();\n * validateEvent.on(str => str.length > 0);\n * validateEvent.on(str => str.length < 100);\n * const results = await validateEvent.emit('test').all(); // [true, true]\n * ```\n */\nexport const createEvent = <T = unknown, R = unknown>(): Event<T, R> => new Event<T, R>();\n\nexport default createEvent;\n\n/**\n * Extracts the listener function type from an Event type.\n * Useful for type-safe listener definitions.\n *\n * @template E - The Event type to extract the listener type from\n *\n * @example\n * ```typescript\n * type MyEvent = Event<string, boolean>;\n * type MyListener = EventHandler<MyEvent>; // (value: string) => boolean | Promise<boolean>\n * ```\n */\nexport type EventHandler<E> = E extends Event<infer T, infer R> ? Listener<T, R> : never;\n\n/**\n * Extracts a filter function type for an Event's parameters.\n * Used for creating type-safe event filters.\n *\n * @template E - The Event type to create a filter for\n */\nexport type EventFilter<E> = FilterFunction<EventParameters<E>>;\n\n/**\n * Extracts a predicate function type for an Event's parameters.\n * Used for type narrowing with event values.\n *\n * @template E - The Event type to create a predicate for\n * @template P - The narrowed type that the predicate validates\n */\nexport type EventPredicate<E, P extends EventParameters<E>> = Predicate<EventParameters<E>, P>;\n\n/**\n * Extracts a mapper function type for transforming Event parameters.\n * Used for creating type-safe event value transformations.\n *\n * @template E - The Event type to create a mapper for\n * @template M - The target type to map event values to\n */\nexport type EventMapper<E, M> = Mapper<EventParameters<E>, M>;\n\n/**\n * Extracts a reducer function type for Event parameters.\n * Used for creating type-safe event value reducers.\n *\n * @template E - The Event type to create a reducer for\n * @template R - The accumulator type for the reduction\n */\nexport type EventReducer<E, R> = Reducer<EventParameters<E>, R>;\n"],"names":["Event","EventIterator","createEvent","createInterval","merge","signal","next","value","receive","done","undefined","return","ListenerRegistry","Signal","Symbol","toStringTag","onDispose","Disposer","sink","emit","bind","handleEvent","event","size","DispatchResult","dispatch","lacks","listener","has","off","on","once","clear","then","onfulfilled","onrejected","catch","finally","onfinally","settle","status","reason","asyncIterator","dispose","events","mergedEvent","interval","counter","intervalEvent","clearInterval","timerId","setInterval"],"mappings":"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"}