source: node_modules/es-toolkit/dist/function/memoize.d.mts

/**
 * Creates a memoized version of the provided function. The memoized function caches
 * results based on the argument it receives, so if the same argument is passed again,
 * it returns the cached result instead of recomputing it.
 *
 * This function works with functions that take zero or just one argument. If your function
 * originally takes multiple arguments, you should refactor it to take a single object or array
 * that combines those arguments.
 *
 * If the argument is not primitive (e.g., arrays or objects), provide a
 * `getCacheKey` function to generate a unique cache key for proper caching.
 *
 * @template F - The type of the function to be memoized.
 * @param {F} fn - The function to be memoized. It should accept a single argument and return a value.
 * @param {MemoizeOptions<Parameters<F>[0], ReturnType<F>>} [options={}] - Optional configuration for the memoization.
 * @param {MemoizeCache<any, V>} [options.cache] - The cache object used to store results. Defaults to a new `Map`.
 * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument.
 *
 * @returns The memoized function with an additional `cache` property that exposes the internal cache.
 *
 * @example
 * // Example using the default cache
 * const add = (x: number) => x + 10;
 * const memoizedAdd = memoize(add);
 *
 * console.log(memoizedAdd(5)); // 15
 * console.log(memoizedAdd(5)); // 15 (cached result)
 * console.log(memoizedAdd.cache.size); // 1
 *
 * @example
 * // Example using a custom resolver
 * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0);
 * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') });
 * console.log(memoizedSum([1, 2])); // 3
 * console.log(memoizedSum([1, 2])); // 3 (cached result)
 * console.log(memoizedSum.cache.size); // 1
 *
 * @example
 * // Example using a custom cache implementation
 * class CustomCache<K, T> implements MemoizeCache<K, T> {
 *   private cache = new Map<K, T>();
 *
 *   set(key: K, value: T): void {
 *     this.cache.set(key, value);
 *   }
 *
 *   get(key: K): T | undefined {
 *     return this.cache.get(key);
 *   }
 *
 *   has(key: K): boolean {
 *     return this.cache.has(key);
 *   }
 *
 *   delete(key: K): boolean {
 *     return this.cache.delete(key);
 *   }
 *
 *   clear(): void {
 *     this.cache.clear();
 *   }
 *
 *   get size(): number {
 *     return this.cache.size;
 *   }
 * }
 * const customCache = new CustomCache<string, number>();
 * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
 * console.log(memoizedSumWithCustomCache([1, 2])); // 3
 * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
 * console.log(memoizedAddWithCustomCache.cache.size); // 1
 */
declare function memoize<F extends (...args: any) => any>(fn: F, options?: {
    cache?: MemoizeCache<any, ReturnType<F>>;
    getCacheKey?: (args: Parameters<F>[0]) => unknown;
}): F & {
    cache: MemoizeCache<any, ReturnType<F>>;
};
/**
 * Represents a cache for memoization, allowing storage and retrieval of computed values.
 *
 * @template K - The type of keys used to store values in the cache.
 * @template V - The type of values stored in the cache.
 */
interface MemoizeCache<K, V> {
    /**
     * Stores a value in the cache with the specified key.
     *
     * @param key - The key to associate with the value.
     * @param value - The value to store in the cache.
     */
    set(key: K, value: V): void;
    /**
     * Retrieves a value from the cache by its key.
     *
     * @param key - The key of the value to retrieve.
     * @returns The value associated with the key, or undefined if the key does not exist.
     */
    get(key: K): V | undefined;
    /**
     * Checks if a value exists in the cache for the specified key.
     *
     * @param key - The key to check for existence in the cache.
     * @returns True if the cache contains the key, false otherwise.
     */
    has(key: K): boolean;
    /**
     * Deletes a value from the cache by its key.
     *
     * @param key - The key of the value to delete.
     * @returns True if the value was successfully deleted, false otherwise.
     */
    delete(key: K): boolean | void;
    /**
     * Clears all values from the cache.
     */
    clear(): void;
    /**
     * The number of entries in the cache.
     */
    size: number;
}

export { type MemoizeCache, memoize };