@thi.ng/cache 2.1.81 → 2.1.83

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-18T13:41:19Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/api.js

@@ -1 +0,0 @@
-export {};

package/lru.js

@@ -1,143 +1,148 @@
 import { DCons } from "@thi.ng/dcons/dcons";
 import { map } from "@thi.ng/transducers/map";
-export class LRUCache {
-    map;
-    items;
-    opts;
-    _size;
-    constructor(pairs, opts) {
-        const _opts = Object.assign({
-            maxlen: Infinity,
-            maxsize: Infinity,
-            map: () => new Map(),
-            ksize: () => 0,
-            vsize: () => 0,
-        }, opts);
-        this.map = _opts.map();
-        this.items = new DCons();
-        this._size = 0;
-        this.opts = _opts;
-        if (pairs) {
-            this.into(pairs);
-        }
-    }
-    get length() {
-        return this.items.length;
-    }
-    get size() {
-        return this._size;
-    }
-    [Symbol.iterator]() {
-        return this.entries();
-    }
-    entries() {
-        return map((e) => [e.k, e], this.items);
-    }
-    keys() {
-        return map((e) => e.k, this.items);
-    }
-    values() {
-        return map((e) => e.v, this.items);
-    }
-    copy() {
-        const c = this.empty();
-        c.items = this.items.copy();
-        let cell = c.items.head;
-        while (cell) {
-            c.map.set(cell.value.k, cell);
-            cell = cell.next;
-        }
-        return c;
-    }
-    empty() {
-        return new LRUCache(null, this.opts);
-    }
-    release() {
-        this._size = 0;
-        this.map.clear();
-        const release = this.opts.release;
-        if (release) {
-            let e;
-            while ((e = this.items.drop())) {
-                release(e.k, e.v);
-            }
-            return true;
-        }
-        return this.items.release();
-    }
-    has(key) {
-        return this.map.has(key);
-    }
-    get(key, notFound) {
-        const e = this.map.get(key);
-        if (e) {
-            return this.resetEntry(e);
-        }
-        return notFound;
-    }
-    set(key, value) {
-        const size = this.opts.ksize(key) + this.opts.vsize(value);
-        const e = this.map.get(key);
-        this._size += Math.max(0, size - (e ? e.value.s : 0));
-        this.ensureSize() && this.doSetEntry(e, key, value, size);
-        return value;
-    }
-    into(pairs) {
-        for (let p of pairs) {
-            this.set(p[0], p[1]);
-        }
-        return this;
-    }
-    getSet(key, retrieve) {
-        const e = this.map.get(key);
-        if (e) {
-            return Promise.resolve(this.resetEntry(e));
-        }
-        return retrieve().then((v) => this.set(key, v));
-    }
-    delete(key) {
-        const e = this.map.get(key);
-        if (e) {
-            this.removeEntry(e);
-            return true;
-        }
+class LRUCache {
+  map;
+  items;
+  opts;
+  _size;
+  constructor(pairs, opts) {
+    const _opts = Object.assign(
+      {
+        maxlen: Infinity,
+        maxsize: Infinity,
+        map: () => /* @__PURE__ */ new Map(),
+        ksize: () => 0,
+        vsize: () => 0
+      },
+      opts
+    );
+    this.map = _opts.map();
+    this.items = new DCons();
+    this._size = 0;
+    this.opts = _opts;
+    if (pairs) {
+      this.into(pairs);
+    }
+  }
+  get length() {
+    return this.items.length;
+  }
+  get size() {
+    return this._size;
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  entries() {
+    return map((e) => [e.k, e], this.items);
+  }
+  keys() {
+    return map((e) => e.k, this.items);
+  }
+  values() {
+    return map((e) => e.v, this.items);
+  }
+  copy() {
+    const c = this.empty();
+    c.items = this.items.copy();
+    let cell = c.items.head;
+    while (cell) {
+      c.map.set(cell.value.k, cell);
+      cell = cell.next;
+    }
+    return c;
+  }
+  empty() {
+    return new LRUCache(null, this.opts);
+  }
+  release() {
+    this._size = 0;
+    this.map.clear();
+    const release = this.opts.release;
+    if (release) {
+      let e;
+      while (e = this.items.drop()) {
+        release(e.k, e.v);
+      }
+      return true;
+    }
+    return this.items.release();
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  get(key, notFound) {
+    const e = this.map.get(key);
+    if (e) {
+      return this.resetEntry(e);
+    }
+    return notFound;
+  }
+  set(key, value) {
+    const size = this.opts.ksize(key) + this.opts.vsize(value);
+    const e = this.map.get(key);
+    this._size += Math.max(0, size - (e ? e.value.s : 0));
+    this.ensureSize() && this.doSetEntry(e, key, value, size);
+    return value;
+  }
+  into(pairs) {
+    for (let p of pairs) {
+      this.set(p[0], p[1]);
+    }
+    return this;
+  }
+  getSet(key, retrieve) {
+    const e = this.map.get(key);
+    if (e) {
+      return Promise.resolve(this.resetEntry(e));
+    }
+    return retrieve().then((v) => this.set(key, v));
+  }
+  delete(key) {
+    const e = this.map.get(key);
+    if (e) {
+      this.removeEntry(e);
+      return true;
+    }
+    return false;
+  }
+  resetEntry(e) {
+    this.items.asTail(e);
+    return e.value.v;
+  }
+  ensureSize() {
+    const release = this.opts.release;
+    const maxs = this.opts.maxsize;
+    const maxl = this.opts.maxlen;
+    while (this._size > maxs || this.length >= maxl) {
+      const e = this.items.drop();
+      if (!e) {
         return false;
-    }
-    resetEntry(e) {
-        this.items.asTail(e);
-        return e.value.v;
-    }
-    ensureSize() {
-        const release = this.opts.release;
-        const maxs = this.opts.maxsize;
-        const maxl = this.opts.maxlen;
-        while (this._size > maxs || this.length >= maxl) {
-            const e = this.items.drop();
-            if (!e) {
-                return false;
-            }
-            this.map.delete(e.k);
-            release && release(e.k, e.v);
-            this._size -= e.s;
-        }
-        return true;
-    }
-    removeEntry(e) {
-        const ee = e.value;
-        this.map.delete(ee.k);
-        this.items.remove(e);
-        this.opts.release && this.opts.release(ee.k, ee.v);
-        this._size -= ee.s;
-    }
-    doSetEntry(e, k, v, s) {
-        if (e) {
-            e.value.v = v;
-            e.value.s = s;
-            this.items.asTail(e);
-        }
-        else {
-            this.items.push({ k, v, s });
-            this.map.set(k, this.items.tail);
-        }
-    }
+      }
+      this.map.delete(e.k);
+      release && release(e.k, e.v);
+      this._size -= e.s;
+    }
+    return true;
+  }
+  removeEntry(e) {
+    const ee = e.value;
+    this.map.delete(ee.k);
+    this.items.remove(e);
+    this.opts.release && this.opts.release(ee.k, ee.v);
+    this._size -= ee.s;
+  }
+  doSetEntry(e, k, v, s) {
+    if (e) {
+      e.value.v = v;
+      e.value.s = s;
+      this.items.asTail(e);
+    } else {
+      this.items.push({ k, v, s });
+      this.map.set(k, this.items.tail);
+    }
+  }
 }
+export {
+  LRUCache
+};

package/mru.js

@@ -1,24 +1,26 @@
 import { LRUCache } from "./lru.js";
-export class MRUCache extends LRUCache {
-    constructor(pairs, opts) {
-        super(pairs, opts);
-    }
-    empty() {
-        return new MRUCache(null, this.opts);
-    }
-    resetEntry(e) {
-        this.items.asHead(e);
-        return e.value.v;
-    }
-    doSetEntry(e, k, v, s) {
-        if (e) {
-            e.value.v = v;
-            e.value.s = s;
-            this.items.asHead(e);
-        }
-        else {
-            this.items.prepend({ k, v, s });
-            this.map.set(k, this.items.head);
-        }
+class MRUCache extends LRUCache {
+  constructor(pairs, opts) {
+    super(pairs, opts);
+  }
+  empty() {
+    return new MRUCache(null, this.opts);
+  }
+  resetEntry(e) {
+    this.items.asHead(e);
+    return e.value.v;
+  }
+  doSetEntry(e, k, v, s) {
+    if (e) {
+      e.value.v = v;
+      e.value.s = s;
+      this.items.asHead(e);
+    } else {
+      this.items.prepend({ k, v, s });
+      this.map.set(k, this.items.head);
     }
+  }
 }
+export {
+  MRUCache
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/cache",
-  "version": "2.1.81",
+  "version": "2.1.83",
   "description": "In-memory cache implementations with ES6 Map-like API and different eviction strategies",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,12 +35,13 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/dcons": "^3.2.76",
-    "@thi.ng/transducers": "^8.8.14"
+    "@thi.ng/api": "^8.9.13",
+    "@thi.ng/dcons": "^3.2.78",
+    "@thi.ng/transducers": "^8.8.16"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -59,7 +62,7 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=12.7"
+    "node": ">=18"
   },
   "files": [
     "./*.js",
@@ -88,5 +91,5 @@
     ],
     "year": 2018
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "25a42a81fac8603a1e440a7aa8bc343276211ff4\n"
 }

package/tlru.js

@@ -1,91 +1,79 @@
 import { LRUCache } from "./lru.js";
-/**
- * Time-aware LRU cache. Extends LRU strategy with TTL (time-to-live)
- * values associated to each entry.
- *
- * @remarks
- * {@link ICache.has} will only return true and {@link ICache.get} only
- * returns a cached value if its TTL hasn't yet expired. When adding a
- * new value to the cache, first removes expired entries and if still
- * not sufficient space then removes entries in LRU order.
- *
- * {@link ICache.set} takes an optional entry specific `ttl` arg. If not
- * given, uses the cache instance's default (provided via ctor option
- * arg). If no instance TTL is given, TTL defaults to 1 hour.
- */
-export class TLRUCache extends LRUCache {
-    constructor(pairs, opts) {
-        opts = Object.assign({ ttl: 60 * 60 * 1000 }, opts);
-        super(pairs, opts);
+class TLRUCache extends LRUCache {
+  constructor(pairs, opts) {
+    opts = Object.assign({ ttl: 60 * 60 * 1e3 }, opts);
+    super(pairs, opts);
+  }
+  empty() {
+    return new TLRUCache(null, this.opts);
+  }
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+  get(key, notFound) {
+    const e = this.map.get(key);
+    if (e) {
+      if (e.value.t >= Date.now()) {
+        return this.resetEntry(e);
+      }
+      this.removeEntry(e);
     }
-    empty() {
-        return new TLRUCache(null, this.opts);
+    return notFound;
+  }
+  set(key, value, ttl = this.opts.ttl) {
+    const size = this.opts.ksize(key) + this.opts.vsize(value);
+    const e = this.map.get(key);
+    this._size += Math.max(0, size - (e ? e.value.s : 0));
+    if (this.ensureSize()) {
+      const t = Date.now() + ttl;
+      if (e) {
+        e.value.v = value;
+        e.value.s = size;
+        e.value.t = t;
+        this.items.asTail(e);
+      } else {
+        this.items.push({
+          k: key,
+          v: value,
+          s: size,
+          t
+        });
+        this.map.set(key, this.items.tail);
+      }
     }
-    has(key) {
-        return this.get(key) !== undefined;
+    return value;
+  }
+  getSet(key, retrieve, ttl = this.opts.ttl) {
+    const e = this.get(key);
+    if (e) {
+      return Promise.resolve(e);
     }
-    get(key, notFound) {
-        const e = this.map.get(key);
-        if (e) {
-            if (e.value.t >= Date.now()) {
-                return this.resetEntry(e);
-            }
-            this.removeEntry(e);
-        }
-        return notFound;
+    return retrieve().then((v) => this.set(key, v, ttl));
+  }
+  prune() {
+    const now = Date.now();
+    let cell = this.items.head;
+    while (cell) {
+      if (cell.value.t < now) {
+        this.removeEntry(cell);
+      }
+      cell = cell.next;
     }
-    set(key, value, ttl = this.opts.ttl) {
-        const size = this.opts.ksize(key) + this.opts.vsize(value);
-        const e = this.map.get(key);
-        this._size += Math.max(0, size - (e ? e.value.s : 0));
-        if (this.ensureSize()) {
-            const t = Date.now() + ttl;
-            if (e) {
-                e.value.v = value;
-                e.value.s = size;
-                e.value.t = t;
-                this.items.asTail(e);
-            }
-            else {
-                this.items.push({
-                    k: key,
-                    v: value,
-                    s: size,
-                    t,
-                });
-                this.map.set(key, this.items.tail);
-            }
-        }
-        return value;
-    }
-    getSet(key, retrieve, ttl = this.opts.ttl) {
-        const e = this.get(key);
-        if (e) {
-            return Promise.resolve(e);
-        }
-        return retrieve().then((v) => this.set(key, v, ttl));
-    }
-    prune() {
-        const now = Date.now();
-        let cell = this.items.head;
-        while (cell) {
-            if (cell.value.t < now) {
-                this.removeEntry(cell);
-            }
-            cell = cell.next;
-        }
-    }
-    ensureSize() {
-        const maxs = this.opts.maxsize;
-        const maxl = this.opts.maxlen;
-        const now = Date.now();
-        let cell = this.items.head;
-        while (cell && (this._size > maxs || this.length >= maxl)) {
-            if (cell.value.t < now) {
-                this.removeEntry(cell);
-            }
-            cell = cell.next;
-        }
-        return super.ensureSize();
+  }
+  ensureSize() {
+    const maxs = this.opts.maxsize;
+    const maxl = this.opts.maxlen;
+    const now = Date.now();
+    let cell = this.items.head;
+    while (cell && (this._size > maxs || this.length >= maxl)) {
+      if (cell.value.t < now) {
+        this.removeEntry(cell);
+      }
+      cell = cell.next;
     }
+    return super.ensureSize();
+  }
 }
+export {
+  TLRUCache
+};