CHANGELOG.md

@@ -105,6 +105,7 @@ well.
   * `maxAge` option -> `ttl`
   * `length` option -> `sizeCalculation`
   * `length` property -> `size`
+  * `del()` method -> `delete()`
   * `prune()` method -> `purgeStale()`
   * `reset()` method -> `clear()`
 * The objects used by `cache.load()` and `cache.dump()` are incompatible

README.md

@@ -96,10 +96,10 @@ If you put more stuff in it, then items will fall out.
 
 ### `max`
 
-The maximum number (or size) of items that remain in the cache
-(assuming no TTL pruning or explicit deletions).  Note that fewer
-items may be stored if size calculation is used, and `maxSize` is
-exceeded.  This must be a positive finite intger.
+The maximum number of items that remain in the cache (assuming no
+TTL pruning or explicit deletions).  Note that fewer items may be
+stored if size calculation is used, and `maxSize` is exceeded.
+This must be a positive finite intger.
 
 At least one of `max`, `maxSize`, or `TTL` is required.  This
 must be a positive integer if set.
@@ -280,9 +280,7 @@ and MAY live in the cache, contributing to its LRU max, long
 after they have expired.
 
 Also, as this cache is optimized for LRU/MRU operations, some of
-the staleness/TTL checks will reduce performance, as they will
-incur overhead by deleting from Map objects rather than simply
-throwing old Map objects away.
+the staleness/TTL checks will reduce performance.
 
 This is not primarily a TTL cache, and does not make strong TTL
 guarantees.  There is no pre-emptive pruning of expired items,
@@ -474,8 +472,7 @@ can be confusing when setting values specifically to `undefined`,
 as in `cache.set(key, undefined)`.  Use `cache.has()` to
 determine whether a key is present in the cache at all.
 
-### `async fetch(key, { updateAgeOnGet, allowStale, size,
-sizeCalculation, ttl, noDisposeOnSet, forceRefresh } = {}) => Promise`
+### `async fetch(key, { updateAgeOnGet, allowStale, size, sizeCalculation, ttl, noDisposeOnSet, forceRefresh } = {}) => Promise`
 
 If the value is in the cache and not stale, then the returned
 Promise resolves to the value.
@@ -736,7 +733,7 @@ const cache = {
     if (cache.timers.has(k)) {
       clearTimeout(cache.timers.get(k))
     }
-    cache.timers.set(k, setTimeout(() => cache.del(k), ttl))
+    cache.timers.set(k, setTimeout(() => cache.delete(k), ttl))
     cache.data.set(k, v)
   },
   get: k => cache.data.get(k),

index.js

@@ -379,6 +379,11 @@ class LRUCache {
       this.sizes[index] = 0
     }
     this.requireSize = (k, v, size, sizeCalculation) => {
+      // provisionally accept background fetches.
+      // actual value size will be checked when they return.
+      if (this.isBackgroundFetch(v)) {
+        return 0
+      }
       if (!isPosInt(size)) {
         if (sizeCalculation) {
           if (typeof sizeCalculation !== 'function') {
@@ -400,9 +405,11 @@ class LRUCache {
     }
     this.addItemSize = (index, size) => {
       this.sizes[index] = size
-      const maxSize = this.maxSize - this.sizes[index]
-      while (this.calculatedSize > maxSize) {
-        this.evict(true)
+      if (this.maxSize) {
+        const maxSize = this.maxSize - this.sizes[index]
+        while (this.calculatedSize > maxSize) {
+          this.evict(true)
+        }
       }
       this.calculatedSize += this.sizes[index]
     }
@@ -586,6 +593,9 @@ class LRUCache {
     // if the item doesn't fit, don't do anything
     // NB: maxEntrySize set to maxSize by default
     if (this.maxEntrySize && size > this.maxEntrySize) {
+      // have to delete, in case a background fetch is there already.
+      // in non-async cases, this is a no-op
+      this.delete(k)
       return this
     }
     let index = this.size === 0 ? undefined : this.keyMap.get(k)

package.json

@@ -1,7 +1,7 @@
 {
   "name": "lru-cache",
   "description": "A cache object that deletes the least-recently-used items.",
-  "version": "7.14.0",
+  "version": "7.14.1",
   "author": "Isaac Z. Schlueter <i@izs.me>",
   "keywords": [
     "mru",

test/size-calculation.ts

@@ -242,3 +242,19 @@ t.test('large item falls out of cache because maxEntrySize', t => {
 
   t.end()
 })
+
+t.test('maxEntrySize, no maxSize', async t => {
+  const c = new LRU<number, string>({
+    max: 10,
+    maxEntrySize: 10,
+    sizeCalculation: s => s.length,
+    fetchMethod: async n => 'x'.repeat(n),
+  })
+  t.equal(await c.fetch(2), 'xx')
+  t.equal(c.size, 1)
+  t.equal(await c.fetch(3), 'xxx')
+  t.equal(c.size, 2)
+  t.equal(await c.fetch(11), 'x'.repeat(11))
+  t.equal(c.size, 2)
+  t.equal(c.has(11), false)
+})