@nxtedition/lib 23.3.34 → 23.4.1

package/cache.js

@@ -0,0 +1,107 @@
+import { LRU } from 'lru-cache'
+
+export class AsyncCache {
+  #lru
+  #prefix
+  #valueSelector
+  #keySelector
+  #dedupe = new Map()
+  #ttl
+  #stale
+
+  constructor(valueSelector, keySelector, opts) {
+    this.#lru = new LRU({ max: 1024 })
+    this.#valueSelector = valueSelector
+
+    if (typeof valueSelector === 'function') {
+      this.#valueSelector = valueSelector
+    } else {
+      throw new TypeError('valueSelector must be a function')
+    }
+
+    if (typeof keySelector === 'function' || keySelector === undefined) {
+      this.#keySelector = keySelector ?? ((...args) => JSON.stringify(args))
+    } else {
+      throw new TypeError('keySelector must be a function')
+    }
+
+    if (opts?.location === undefined) {
+      this.#prefix = (opts?.location ?? Math.random().toString(36)) + ':'
+    } else if (typeof opts?.location === 'string') {
+      this.#prefix = opts.location
+    } else {
+      throw new TypeError('location must be undefined or a string')
+    }
+
+    if (typeof opts?.ttl === 'number' || opts?.ttl === undefined) {
+      const ttl = opts.ttl
+      this.#ttl = (val, key) => ttl
+    } else if (typeof opts?.ttl === 'function') {
+      this.#ttl = opts.ttl
+    } else {
+      throw new TypeError('ttl must be a undefined, number or a function')
+    }
+
+    if (typeof opts?.stale === 'number' || opts?.stale === undefined) {
+      const stale = opts.stale
+      this.#stale = () => stale
+    } else if (typeof opts?.stale === 'function') {
+      this.#stale = opts.stale
+    } else {
+      throw new TypeError('stale must be a undefined, number or a function')
+    }
+  }
+
+  async get(...args) {
+    const key = this.#keySelector(...args)
+
+    if (typeof key !== 'string' || key.length === 0) {
+      throw new TypeError('keySelector must return a non-empty string')
+    }
+
+    let cached = this.#lru.get(key)
+
+    if (!cached) {
+      const raw = globalThis.localStorage.getItem(this.#prefix + key)
+      cached = raw ? JSON.parse(raw) : null
+    }
+
+    if (cached) {
+      if (Date.now() < cached.expire) {
+        return cached.value
+      }
+
+      if (Date.now() - cached.expire >= this.#stale(cached.value, key)) {
+        // stale-while-revalidate has also expired, dont use cached value
+        cached = null
+      }
+    }
+
+    let promise = this.#dedupe.get(key)
+    if (!promise) {
+      promise = this.#valueSelector(...args).then(
+        (value) => {
+          this.#dedupe.delete(key)
+
+          cached = {
+            expire: Date.now() + this.#ttl(value, key),
+            value,
+          }
+
+          globalThis.localStorage.setItem(this.#prefix + key, JSON.stringify(cached))
+          this.#lru.set(key, cached)
+
+          return value
+        },
+        (err) => {
+          this.#dedupe.delete(key)
+
+          throw err
+        },
+      )
+      this.#dedupe.set(key, promise)
+    }
+
+    return cached ? cached.value : promise
+  }
+}

package/couch.js

@@ -1091,6 +1091,7 @@ export function request(url, opts) {
       accept: 'application/json',
       ...opts.headers,
     },
+    cache: false,
     body:
       opts.body != null && typeof opts.body === 'object' ? JSON.stringify(opts.body) : opts.body,
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "23.3.34",
+  "version": "23.4.1",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -9,6 +9,7 @@
     "ass.js",
     "rxjs/*",
     "util/*",
+    "cache.js",
     "http-client.js",
     "subtract-ranges.js",
     "serializers.js",