import "./_dnt.polyfills.js";
import { PureEventWithApply } from "./pure_event.js";
/**
 * 函数转化，一个新函数：它的第一个参数 将作为 原函数的 this
 */
export declare const uncurryThisFn: <T, ARGS extends readonly unknown[], R>(func: (this: T, ...args: ARGS) => R) => ((self: T, ...restArgs: ARGS) => R);
export type UncurryThisFn<T> = T extends Func ? ReturnType<typeof uncurryThisFn<Func.This<T>, Func.Args<T>, Func.Return<T>>> : never;
/**
 * 函数转化，一个新函数，它的this 是原函数的第一个参数
 */
export declare const curryThisFn: <T, ARGS extends readonly unknown[], R>(func: (self: T, ...args: ARGS) => R) => ((this: T, ...args: ARGS) => R);
export type CurryThisFn<T> = T extends Func ? ReturnType<typeof curryThisFn<Func.This<T>, Func.Args<T>, Func.Return<T>>> : never;
/**
 * 类型安全的函数定义
 */
export type Func<This = any, Arguments extends readonly unknown[] = any[], Return extends unknown = any> = Arguments["length"] extends 0 ? (this: This) => Return : (this: This, ...args: Arguments) => Return;
export declare namespace Func {
    type Return<F> = F extends Func ? ReturnType<F> : never;
    type AwaitedResult<F> = {
        type: "resolved";
        result: Awaited<Return<F>>;
    } | {
        type: "rejected";
        error: unknown;
    };
    type Args<F> = F extends Func ? Parameters<F> : never;
    type This<F> = F extends Func<infer T> ? T : never;
    type SetReturn<T, R> = Func<This<T>, Args<T>, R>;
}
type KeyFun<F extends Func> = Func<ThisParameterType<F>, Parameters<F>>;
export type FuncRemember<F extends Func, K extends KeyFun<F> | void = void> = F & {
    readonly source: F;
    readonly key: Func.Return<K> | undefined;
    readonly runned: boolean;
    readonly returnValue: Func.Return<F> | undefined;
    readonly awaitedReturnValue: Func.AwaitedResult<F> | undefined;
    reset(): void;
    rerun(...args: Parameters<F>): Func.Return<F>;
};
export declare namespace func_remember {
    type Return<F extends Func, K extends KeyFun<F> | void = void> = FuncRemember<F, K>;
}
/**
 * 让一个函数的返回结果是缓存的
 * @param key 自定义缓存key生成器，如果生成的key不一样，那么缓存失效
 * @returns
 */
export declare const func_remember: <F extends Func, K extends Func<ThisParameterType<F>, Parameters<F>> | void | void>(func: F, key?: K, cacheAwaited?: boolean) => FuncRemember<F, K>;
/**
 * 包裹一个“目标函数”，将它的执行权交给“包裹函数”。
 * 包裹函数可以在目标函数执行之前或者执行之后做一些工作，比如参数检查，比如返回值修改
 * @param func 目标函数
 * @param wrapper 包裹函数，第一个参数是 context，可以获得详细的上下文；第二个参数是 next，可以用于快速执行“目标函数”
 */
export declare const func_wrap: <F extends Func, R>(func: F, wrapper: (context: {
    target: F;
    this: ThisParameterType<F>;
    arguments: Parameters<F>;
}, next: () => ReturnType<F>) => R) => ((this: ThisParameterType<F>, ...args: Parameters<F>) => R);
type PrototypeToThis<T> = T extends String ? string : T extends Number ? number : T extends Boolean ? boolean : T extends BigInt ? bigint : T extends Symbol ? symbol : T;
/**
 * 向某一个对象配置函数属性
 */
export declare const extendsMethod: <T extends object>(target: T, prop: PropertyKey, method: Func<PrototypeToThis<T>>) => void;
/**
 * 向某一个对象配置getter属性
 */
export declare const extendsGetter: <T extends object>(target: T, prop: PropertyKey, getter: Func<PrototypeToThis<T>, []>) => void;
export interface FuncCatch {
    <E = unknown, F extends Func = Func>(fn: F, errorParser?: (err: unknown) => E): FuncCatch.Wrapper<E, F>;
    wrapSuccess: <R>(resule: R) => FuncCatch.SuccessReturn<R>;
    wrapError: <E>(err: E, errorParser?: (err: unknown) => E) => FuncCatch.ErrorReturn<E>;
}
export declare namespace FuncCatch {
    type Wrapper<E, F extends Func> = Func<ThisParameterType<F>, Parameters<F>, Return<E, ReturnType<F>>> & {
        catchType<E>(errorParser?: (err: unknown) => E): Wrapper<E, F>;
    };
    type SuccessReturn<R> = readonly [undefined, R] & {
        readonly success: true;
        readonly result: R;
        readonly error: void;
    };
    type ErrorReturn<E> = readonly [E, undefined] & {
        readonly success: false;
        readonly result: void;
        readonly error: E;
    };
    type Return<E, R> = [R] extends [never] ? ErrorReturn<E> : R extends PromiseLike<infer T> ? PromiseLike<SuccessReturn<T> | ErrorReturn<E>> : SuccessReturn<R> | ErrorReturn<E>;
}
/**
 * 包裹一个函数，并对其进行错误捕捉并返回
 */
export declare const func_catch: FuncCatch;
/**
 * 一个能延迟执行的函数包裹
 * 和 func_remember 不同，`func_lazy(...args)` 等同于 `func_remember()(...args)`
 * @param factory
 * @returns
 */
export declare const func_lazy: <T extends Func>(factory: Func.SetReturn<T, T>) => T;
declare const effect_symbol: unique symbol;
type WithEffect<T = unknown> = {
    [effect_symbol]: Func<void, [T]>;
};
/**
 * 让一个对象附带副作用
 * @param source
 * @param effect
 * @returns
 */
export declare const withEffect: <T extends object>(source: T, effect: Func<void, [T]>) => T & WithEffect<T>;
/**
 * 执行副作用
 * @param sources
 */
export declare const applyEffect: (...sources: (WithEffect | object)[]) => void;
/**
 * 并行执行一组函数，并限制并发数量。
 *
 * @template T - 函数的类型，这些函数不接受参数
 * @param {Iterable<T>} funcs - 一个可迭代的函数集合，这些函数将被并行执行。
 * @param {number} limit - 并发执行函数的最大数量。
 * @returns {{ emit: (data: { source: T; result: FuncCatch.Return<unknown, Func.Return<T>> }) => void, on: (cb: (data: { source: T; result: FuncCatch.Return<unknown, Func.Return<T>> }) => void) => () => void, off: (cb: (data: { source: T; result: FuncCatch.Return<unknown, Func.Return<T>> }) => void) => void, once: (cb: (data: { source: T; result: FuncCatch.Return<unknown, Func.Return<T>> }) => void) => () => void, then: Promise<void>['then'] }} 返回一个对象，包含一个事件发射器 `returns` 用于监听每个函数完成时的结果，以及一个 `then` 方法，该方法在所有函数都执行完毕后 resolve。
 * 每个函数的结果会通过 `returns` 事件的 `emit` 方法发出，数据格式为 `{ source: T; result: FuncCatch.Return<unknown, Func.Return<T>> }`。
 * `result` 是一个元组，成功时为 `[undefined, R]`，失败时为 `[E, undefined]`，并附带 `success`、`result` 和 `error` 属性。
 */
export declare const func_parallel_limit: <T extends Func<void>>(funcs: Iterable<T> | AsyncIterable<T>, limit: number) => PureEventWithApply<{
    source: T;
    result: FuncCatch.Return<unknown, Func.Return<T>>;
}> & PromiseLike<void[]>;
export {};
//# sourceMappingURL=func.d.ts.map