"Fossies" - the Fresh Open Source Software Archive

Member "node-v12.18.4-win-x86/node_modules/npm/node_modules/mem/index.d.ts" (18 Feb 2020, 2605 Bytes) of package /windows/www/node-v12.18.4-win-x86.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) TypeScript source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    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;