import type { DebounceFilterOptions, MaybeRefOrGetter } from '@vueuse/core' type FunctionArgs = (...args: any[]) => any // Default function to generate a cache key function defaultGetCacheKey(): string { return 'default' } /** * Creates a cached debounced version of the given function. * * @param fn - The function to debounce. * @param ms - The debounce delay in milliseconds. Default is 500ms. * @param getCacheKey - Function to generate a unique cache key based on the arguments. * @param options - Additional options for debouncing. * * @returns A debounced version of the input function with caching. */ export function useCachedDebouncedFunction<T extends FunctionArgs>( fn: T, ms: MaybeRefOrGetter<number> = 500, getCacheKey: (...args: Parameters<T>) => string | number = defaultGetCacheKey, options: DebounceFilterOptions = {}, ): (...args: Parameters<T>) => ReturnType<T> { // Cache to store debounced functions based on a unique key const debounceCache = new Map<string | number, any>() return (...args: Parameters<T>): ReturnType<T> => { // Generate a unique key for the given arguments const key = getCacheKey(...args) // If the debounced function for the given key is not in the cache, create and cache it if (!debounceCache.has(key)) { const debouncedFn = useDebounceFn(fn, ms, options) debounceCache.set(key, debouncedFn) } // Retrieve the cached debounced function const debouncedFn = debounceCache.get(key) // Call and return the result of the debounced function return debouncedFn!(...args) } }