@adviser/cement 0.3.16 → 0.3.18

package/test/index.cjs

@@ -865,6 +865,100 @@ var WrapperSysAbstraction = class {
   }
 };
 
+// src/lru-map-set.ts
+var LRUMap = class {
+  constructor(c = {}) {
+    this._map = /* @__PURE__ */ new Map();
+    this.param = {
+      maxEntries: c.maxEntries || 100,
+      maxAge: c.maxAge || 0
+    };
+  }
+  touch(key) {
+    if (!this._map.has(key)) {
+      throw new Error(`key not found in cache: ${key}`);
+    }
+    const value = this._map.get(key);
+    this._map.delete(key);
+    this._map.set(key, value);
+    return value;
+  }
+  setParam(param2 = {}) {
+    if (typeof param2.maxEntries === "number") {
+      this.param.maxEntries = param2.maxEntries;
+      if (param2.maxEntries > 0 && this._map.size > param2.maxEntries) {
+        const toDelete = [];
+        let cacheSize = this._map.size;
+        for (const key of this._map.keys()) {
+          if (cacheSize > param2.maxEntries) {
+            toDelete.push(key);
+            cacheSize--;
+          } else {
+            break;
+          }
+        }
+        for (const key of toDelete) {
+          this._map.delete(key);
+        }
+      }
+    }
+  }
+  has(key) {
+    return this._map.has(key);
+  }
+  get size() {
+    return this._map.size;
+  }
+  async getSet(key, createFN) {
+    const val = this.get(key);
+    if (val) {
+      return val;
+    } else {
+      const val2 = await createFN(key);
+      this.set(key, val2);
+      return val2;
+    }
+  }
+  get(key) {
+    if (this._map.has(key)) {
+      return this.touch(key);
+    }
+    return this._map.get(key);
+  }
+  set(key, value) {
+    this._map.delete(key);
+    if (this.param.maxEntries > 0 && this._map.size >= this.param.maxEntries) {
+      this._map.delete(this._map.keys().next().value);
+      this._map.set(key, value);
+    } else {
+      this._map.set(key, value);
+    }
+  }
+  delete(key) {
+    this._map.delete(key);
+  }
+  clear() {
+    this._map.clear();
+  }
+  forEach(callbackfn) {
+    this._map.forEach(callbackfn);
+  }
+  entries() {
+    return this._map.entries();
+  }
+  // *entries(): IterableIterator<[T, K]> {
+  //   for (const x of this._cache.entries()) {
+  //     yield x;
+  //   }
+  // }
+  //   getLeastRecent(): K {
+  //     return Array.from(this.cache)[0];
+  //   }
+  //   getMostRecent(): K {
+  //     return Array.from(this.cache)[this.cache.size - 1];
+  //   }
+};
+
 // src/resolve-once.ts
 var ResolveOnce = class {
   constructor(ctx) {
@@ -958,9 +1052,13 @@ var ResolveOnce = class {
   }
 };
 var Keyed = class {
-  constructor(factory) {
-    this._map = /* @__PURE__ */ new Map();
+  constructor(factory, params) {
+    var _a;
     this.factory = factory;
+    this._map = new LRUMap((_a = params == null ? void 0 : params.lru) != null ? _a : { maxEntries: -1 });
+  }
+  setParam(params) {
+    this._map.setParam(params.lru);
   }
   async asyncGet(key) {
     return this.get(await key());
@@ -987,8 +1085,8 @@ var Keyed = class {
   }
 };
 var KeyedResolvOnce = class extends Keyed {
-  constructor() {
-    super((key) => new ResolveOnce(key));
+  constructor(kp = {}) {
+    super((key) => new ResolveOnce(key), kp);
   }
   /**
    *