333

schangxiang@126.com

2025-09-19 18966e02fb573c7e2bb0c6426ed792b38b910940

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
declare namespace mem {
    interface CacheStorage<KeyType extends unknown, ValueType extends unknown> {
        has(key: KeyType): boolean;
        get(key: KeyType): ValueType | undefined;
        set(key: KeyType, value: ValueType): void;
        delete(key: KeyType): void;
        clear?: () => void;
    }
 
    interface Options<
        ArgumentsType extends unknown[],
        CacheKeyType extends unknown,
        ReturnType extends unknown
    > {
        /**
        Milliseconds until the cache expires.
 
        @default Infinity
        */
        readonly maxAge?: number;
 
        /**
        Determines the cache key for storing the result based on the function arguments. By default, if there's only one argument and it's a [primitive](https://developer.mozilla.org/en-US/docs/Glossary/Primitive), it's used directly as a key, otherwise it's all the function arguments JSON stringified as an array.
 
        You could for example change it to only cache on the first argument `x => JSON.stringify(x)`.
        */
        readonly cacheKey?: (...arguments: ArgumentsType) => CacheKeyType;
 
        /**
        Use a different cache storage. You could for example use a `WeakMap` instead or [`quick-lru`](https://github.com/sindresorhus/quick-lru) for a LRU cache.
 
        @default new Map()
        */
        readonly cache?: CacheStorage<CacheKeyType, {data: ReturnType; maxAge: number}>;
 
        /**
        Cache rejected promises.
 
        @default false
        */
        readonly cachePromiseRejection?: boolean;
    }
}
 
declare const mem: {
    /**
    [Memoize](https://en.wikipedia.org/wiki/Memoization) functions - An optimization used to speed up consecutive function calls by caching the result of calls with identical input.
 
    @param fn - Function to be memoized.
 
    @example
    ```
    import mem = require('mem');
 
    let i = 0;
    const counter = () => ++i;
    const memoized = mem(counter);
 
    memoized('foo');
    //=> 1
 
    // Cached as it's the same arguments
    memoized('foo');
    //=> 1
 
    // Not cached anymore as the arguments changed
    memoized('bar');
    //=> 2
 
    memoized('bar');
    //=> 2
    ```
    */
    <
        ArgumentsType extends unknown[],
        ReturnType extends unknown,
        CacheKeyType extends unknown
    >(
        fn: (...arguments: ArgumentsType) => ReturnType,
        options?: mem.Options<ArgumentsType, CacheKeyType, ReturnType>
    ): (...arguments: ArgumentsType) => ReturnType;
 
    /**
    Clear all cached data of a memoized function.
 
    @param fn - Memoized function.
    */
    clear<ArgumentsType extends unknown[], ReturnType extends unknown>(
        fn: (...arguments: ArgumentsType) => ReturnType
    ): void;
 
    // TODO: Remove this for the next major release
    default: typeof mem;
};
 
export = mem;