/** * 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[0], ReturnType>} [options={}] - Optional configuration for the memoization. * @param {MemoizeCache} [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 implements MemoizeCache { * private cache = new Map(); * * 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(); * 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 any>(fn: F, options?: { cache?: MemoizeCache>; getCacheKey?: (args: Parameters[0]) => unknown; }): F & { cache: MemoizeCache>; }; /** * 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 { /** * 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 };