.config/coc/extensions/node_modules/coc-prettier/node_modules/mem/index.d.ts

   1 declare namespace mem {
   2         interface CacheStorage<KeyType extends unknown, ValueType extends unknown> {
   3                 has(key: KeyType): boolean;
   4                 get(key: KeyType): ValueType | undefined;
   5                 set(key: KeyType, value: ValueType): void;
   6                 delete(key: KeyType): void;
   7                 clear?: () => void;
   8         }
   9
  10         interface Options<
  11                 ArgumentsType extends unknown[],
  12                 CacheKeyType extends unknown,
  13                 ReturnType extends unknown
  14         > {
  15                 /**
  16                 Milliseconds until the cache expires.
  17
  18                 @default Infinity
  19                 */
  20                 readonly maxAge?: number;
  21
  22                 /**
  23                 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.
  24
  25                 You could for example change it to only cache on the first argument `x => JSON.stringify(x)`.
  26                 */
  27                 readonly cacheKey?: (...arguments: ArgumentsType) => CacheKeyType;
  28
  29                 /**
  30                 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.
  31
  32                 @default new Map()
  33                 */
  34                 readonly cache?: CacheStorage<CacheKeyType, {data: ReturnType; maxAge: number}>;
  35
  36                 /**
  37                 Cache rejected promises.
  38
  39                 @default false
  40                 */
  41                 readonly cachePromiseRejection?: boolean;
  42         }
  43 }
  44
  45 declare const mem: {
  46         /**
  47         [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.
  48
  49         @param fn - Function to be memoized.
  50
  51         @example
  52         ```
  53         import mem = require('mem');
  54
  55         let i = 0;
  56         const counter = () => ++i;
  57         const memoized = mem(counter);
  58
  59         memoized('foo');
  60         //=> 1
  61
  62         // Cached as it's the same arguments
  63         memoized('foo');
  64         //=> 1
  65
  66         // Not cached anymore as the arguments changed
  67         memoized('bar');
  68         //=> 2
  69
  70         memoized('bar');
  71         //=> 2
  72         ```
  73         */
  74         <
  75                 ArgumentsType extends unknown[],
  76                 ReturnType extends unknown,
  77                 CacheKeyType extends unknown
  78         >(
  79                 fn: (...arguments: ArgumentsType) => ReturnType,
  80                 options?: mem.Options<ArgumentsType, CacheKeyType, ReturnType>
  81         ): (...arguments: ArgumentsType) => ReturnType;
  82
  83         /**
  84         Clear all cached data of a memoized function.
  85
  86         @param fn - Memoized function.
  87         */
  88         clear<ArgumentsType extends unknown[], ReturnType extends unknown>(
  89                 fn: (...arguments: ArgumentsType) => ReturnType
  90         ): void;
  91
  92         // TODO: Remove this for the next major release
  93         default: typeof mem;
  94 };
  95
  96 export = mem;