optimism

defaultMakeCacheKey: (...args: any[]) => object;

dep: <TKey>(options?: {
    subscribe: Dep<TKey>['subscribe'];
}) => OptimisticDependencyFunction<TKey>;

nonReactive: <R>(fn: () => R) => R;

wrap: <
    TArgs extends any[],
    TResult,
    TKeyArgs extends any[] = TArgs,
    TCacheKey = any
>(
    originalFunction: (...args: TArgs) => TResult,
    {
        max,
        makeCacheKey,
        keyArgs,
        subscribe,
    }?: OptimisticWrapOptions<TArgs, TKeyArgs>
) => OptimisticWrapperFunction<TArgs, TResult, TKeyArgs, TCacheKey>;

type OptimisticDependencyFunction<TKey> = ((key: TKey) => void) & {
    dirty: (key: TKey, entryMethodName?: EntryMethodName) => void;
};

type OptimisticWrapOptions<
    TArgs extends any[],
    TKeyArgs extends any[] = TArgs,
    TCacheKey = any
> = {
    max?: number;
    keyArgs?: (...args: TArgs) => TKeyArgs;
    makeCacheKey?: (...args: TKeyArgs) => TCacheKey;
    subscribe?: (...args: TArgs) => void | (() => any);
};

type OptimisticWrapperFunction<
    TArgs extends any[],
    TResult,
    TKeyArgs extends any[] = TArgs,
    TCacheKey = any
> = ((...args: TArgs) => TResult) & {
    readonly size: number;
    options: OptimisticWrapOptions<TArgs, TKeyArgs, TCacheKey>;
    dirty: (...args: TKeyArgs) => void;
    dirtyKey: (key: TCacheKey) => void;
    peek: (...args: TKeyArgs) => TResult | undefined;
    peekKey: (key: TCacheKey) => TResult | undefined;
    forget: (...args: TKeyArgs) => boolean;
    forgetKey: (key: TCacheKey) => boolean;
    getKey: (...args: TArgs) => TCacheKey;
    makeCacheKey: (...args: TKeyArgs) => TCacheKey;
};