Class ResolveCacheInternal

Iterating over the cache itself yields the same results as LRUCache.entries

Clear the cache entirely, throwing away all values.

Deletes a key out of the cache. Returns true if the key was deleted, false otherwise.

Return an array of [key, LRUCache.Entry] tuples which can be passed to cache.load()

Return a generator yielding [key, value] pairs, in order from most recently used to least recently used.

Make an asynchronous cached fetch using the LRUCache.OptionsBase.fetchMethod function.

If multiple fetches for the same key are issued, then they will all be coalesced into a single call to fetchMethod.

Note that this means that handling options such as LRUCache.OptionsBase.allowStaleOnFetchAbort, LRUCache.FetchOptions.signal, and LRUCache.OptionsBase.allowStaleOnFetchRejection will be determined by the FIRST fetch() call for a given key.

This is a known (fixable) shortcoming which will be addresed on when someone complains about it, as the fix would involve added complexity and may not be worth the costs for this edge case.

Find a value for which the supplied fn method returns a truthy value, similar to Array.find(). fn is called as fn(value, key, cache).

Call the supplied function on each item in the cache, in order from most recently used to least recently used. fn is called as fn(value, key, cache). Does not update age or recenty of use. Does not iterate over stale values.

Return a value from the cache. Will update the recency of the cache entry found.

If the key is not found, get() will return undefined.

Return the remaining TTL time for a given entry key

Check if a key is in the cache, without updating the recency of use. Will return false if the item is stale, even though it is technically in the cache.

Will not update item age unless LRUCache.OptionsBase.updateAgeOnHas is set.

Return a generator yielding the keys in the cache, in order from most recently used to least recently used.

Reset the cache and load in the items in entries in the order listed. Note that the shape of the resulting cache may be different if the same options are not used in both caches.

Like LRUCache#get but doesn't update recency or delete stale items.

Returns undefined if the item is stale, unless LRUCache.OptionsBase.allowStale is set.

Evict the least recently used item, returning its value or undefined if cache is empty.

Delete any stale entries. Returns true if anything was removed, false otherwise.

Inverse order version of LRUCache.entries

Return a generator yielding [key, value] pairs, in order from least recently used to most recently used.

The same as LRUCache.forEach but items are iterated over in reverse order. (ie, less recently used items are iterated over first.)

Inverse order version of LRUCache.keys

Return a generator yielding the keys in the cache, in order from least recently used to most recently used.

Inverse order version of LRUCache.values

Return a generator yielding the values in the cache, in order from least recently used to most recently used.

Add a value to the cache.

Note: if undefined is specified as a value, this is an alias for LRUCache#delete

Return a generator yielding the values in the cache, in order from most recently used to least recently used.

Do not call this method unless you need to inspect the inner workings of the cache. If anything returned by this object is modified in any way, strange breakage may occur.

These fields are private for a reason!