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;
|
