import "./_dnt.polyfills.js";
import type { Func } from "./func.js";
/** PureEvent 的监听函数定义 */
export type PureEventFun<T> = (data: T) => unknown;
type PureEventOffResult = boolean | Promise<PromiseSettledResult<unknown>>;
/** PureEvent 移除监听函数定义 */
export type PureEventOff = () => PureEventOffResult;
/** PureEvent 监听函数可选参数 */
export interface PureEventListenOptions {
    /** 自定义事件索引 */
    key?: unknown;
    /** 销毁事件时的自定义函数 */
    onDispose?: Func;
}
/** PureEvent 监听函数可选参数 */
export interface PureEventOnceOptions<T> extends PureEventListenOptions {
    filter?: (data: T) => boolean;
}
export type PureEventOncePromiseWithResolvers<T> = Promise<T> & {
    resolve(data: T): void;
    reject(reason?: unknown): void;
};
/**
 * 一个现代化的单事件监听器
 *
 * 对异步与错误捕捉有着一流的支持
 *
 * 可自定义移除事件时的触发器
 *
 * @example
 * ```ts
 * import { PureEvent } from "@gaubee/util";
 * const pevent = new PureEvent<string>();
 *
 * /// basic
 * // add listen
 * const off = pevent.on((data) => console.log("on", data));
 * // dispatch listen
 * pevent.emit("hi");
 * // remove listen
 * off();
 *
 * // add listen with custom key
 * pevent.on((data) => console.log("on", data), { key: "key1" });
 * // remove listen with custom key
 * pevent.off("key1");
 *
 * // add listen width dispose function
 * const off = pevent.on((data) => console.log("on", data), {
 *   onDispose: async () => {
 *     console.log("off");
 *     return 123;
 *   },
 * });
 * // remove listen and run dispatch function
 * console.log(await off()); // { status: "fulfilled", value: 123 }
 *
 * /// once
 * // add one time listen with callback function
 * pevent.once((data) => console.log("once", data));
 * // add one time listen without callback function and return promise
 * pevent.once().then((data) => console.log("once.then", data));
 * // add one time listen with filter function
 * pevent.once({ filter(data){ return data == "match" } }).then((data) => console.log("once filter", data));
 *
 * // best practices for multiple events:
 * // use explicit properties instead of event name mappings
 * class YourClass {
 *      onStart = new PureEvent<void>()
 *      onData = new PureEvent<void>()
 *      onEnd = new PureEvent<void>()
 * }
 * ```
 */
export declare class PureEvent<T> {
    constructor();
    /** 监听表 */
    readonly events: Map<unknown, {
        cb: PureEventFun<T>;
        onDispose: Func | undefined;
        off: PureEventOff;
    }>;
    /** 有多少监听 */
    get size(): number;
    /** 判断是否已经存在指定监听 */
    has(key: unknown): boolean;
    /**
     * 附加监听
     * 同 watch
     * @deprecated 使用 watch
     */
    on(cb: PureEventFun<T>, options?: PureEventListenOptions): PureEventOff;
    /**
     * 附加监听
     * 可以自定义唯一索引 key，如果重复，会移除之前的监听
     */
    watch(cb: PureEventFun<T>, options?: PureEventListenOptions): PureEventOff;
    /**
     * 移除指定监听
     * 同 unwatch
     * @deprecated 使用 unwatch
     */
    off(key: unknown): PureEventOffResult;
    /**
     * 移除指定监听
     * 如果没有指定事件，那么返回false
     * 否则，如果没有自定义 移除监听器（onDispose），那么直接返回true
     * 否则返回 PromiseSettledResult
     */
    unwatch(key: unknown): PureEventOffResult;
    /**
     * 清理所有的监听
     * 会返回所有被清理的事件的 key
     * 如果自定义了 移除监听器（onDispose）, 那么会在 disposeReturn 中携带结果
     */
    cleanSync(): {
        key: unknown;
        disposeReturn: undefined | Promise<PromiseSettledResult<unknown>>;
    }[];
    /**
     * 清理所有的监听，
     * 并等待所有的 disposeReturn 返回结果
     */
    clean(): Promise<{
        key: unknown;
        disposeReturn: undefined | PromiseSettledResult<unknown>;
    }[]>;
    emit(data: T): Promise<void>;
    once(options?: PureEventOnceOptions<T>): PureEventOncePromiseWithResolvers<T>;
    once(cb?: null, options?: PureEventOnceOptions<T>): PureEventOncePromiseWithResolvers<T>;
    once(cb: PureEventFun<T>, options?: PureEventOnceOptions<T>): PureEventOff;
}
export type PureEventWithApply<T> = PureEvent<T> & PureEvent<T>["watch"];
export declare const pureEvent: <T>() => PureEventWithApply<T>;
/**
 * PureEvent 的委托类，基于委托，可以实现更新委托内核
 *
 * @example
 * ```ts
 * const pevent_source = new PureEvent<string>()
 * const pevent_delegate = new PureEventDelegate<string>()
 * pevent_delegate.byPureEvent = pevent_source
 *
 * pevent_source.on((data) => console.log('by source', data))
 * pevent_delegate.on((data) => console.log('by delegate', data))
 *
 * pevent_source.emit('from source')
 * pevent_delegate.emit('from delegate')
 * ```
 */
export declare class PureEventDelegate<T> extends PureEvent<T> {
    byPureEvent: PureEvent<T>;
    constructor(byPureEvent?: PureEvent<T>);
}
type PureEventDelegateWithApply<T> = PureEventDelegate<T> & PureEventDelegate<T>["watch"];
export declare const pureEventDelegate: <T>() => PureEventDelegateWithApply<T>;
export {};
//# sourceMappingURL=pure_event.d.ts.map