fast-ttl-cache 0.1.2 → 0.1.4

package/README.md

@@ -20,17 +20,21 @@ import FastTTLCache from 'fast-ttl-cache';
 const cache = new FastTTLCache({
   ttl: 5 * 1000, // ttl in millseconds, get an outdated data will return null and delete it
   capacity: 1000, // max capacity, When the capacity is exceeded, the least recently updated data will be removed.
+  cloneLevel: 0, // 0 (no clone), 1 (shallow clone), 2 (deep clone), defaults to 0
 });
 
 cache.put('key1', 'value1');
 cache.put('key2', 'value2');
-cache.get('key2'); // return value2
+cache.put('key3', 'value3');
+console.log(cache.get('key2')); // return value2
 
 // wait for 5 seconds
+await new Promise(resolve => setTimeout(resolve, 5000));
+
 cache.get('key1'); // return null and key1 will be removed
-cache.size; // return 1, key2 is outdated but is not been removed yet
+cache.size; // return 2, key2 & key3 are outdated but are not been removed yet
 
-cache.get('key2'); // return null and key2 will be removed
+cache.get('key3'); // return null and key2 & key3 will be removed
 cache.size; // return 0
 ```
 
@@ -39,6 +43,7 @@ cache.size; // return 0
 
 - ```options.ttl```: number of millseconds, defaults to Infinity
 - ```options.capacity```: number of max capacity, defaults to Infinity
+- ```options.cloneLevel```: number of clone level, defaults to 0 (no clone), 1 (shallow clone), 2 (deep clone)
 
 ```FastTTLCache.prototype.put(key, value)```
 
@@ -47,6 +52,9 @@ cache.size; // return 0
 ```FastTTLCache.prototype.get(key)```
 
 - Get the value of the key from cache, return null if the key is not exists or has been expired.
+- if cloneLevel is 0, return the original data
+- if cloneLevel is 1, return the shallow cloned data
+- if cloneLevel is 2, return the deep cloned data
 
 ```FastTTLCache.prototype.size```
 

package/dist/index.d.mts

@@ -12,36 +12,41 @@ declare class FastTTLCache {
     /** 存储缓存项的Map */
     private store;
     /** 链表头部指针，指向最久未更新的节点 */
-    head: CacheItem | null;
+    head: CacheItem;
     /** 链表尾部指针，指向最新更新的节点 */
-    tail: CacheItem | null;
+    tail: CacheItem;
     /** 缓存大小 */
     size: number;
+    /** 数据 clone 方法 */
+    private cloneMethod;
     /**
      * 构造函数
-     * @param options 配置选项，包含ttl(过期时间)和capacity(容量)
+     * @param {CacheOptions} options 配置选项，包含ttl(过期时间)和capacity(容量)
      */
     constructor(options?: CacheOptions);
     /**
      * 获取缓存，惰性删除
-     * @param key 缓存键
+     * @param {string} key 缓存键
      * @returns 如果缓存存在且未过期返回值，否则返回null
      */
-    get(key: string): any | null;
+    get(key: string): any;
     /**
      * 设置缓存，包含已存在或新增
-     * @param key 缓存键
-     * @param value 缓存值
+     * @param {string} key 缓存键
+     * @param {any} value 缓存值
      */
     put(key: string, value: any): void;
     /**
      * 移除节点
-     * @param item CacheItem
+     * @param {CacheItem} item
+     * @param {boolean} [isExpire = false] 是否为过期删除
+     * @returns {boolean} 是否删除成功
      */
     private del;
     /**
      * 将节点移动到队尾，队尾的节点一定是最后一个更新的
-     * @param item CacheItem
+     * @param {CacheItem} item
+     * @returns void
      */
     private moveToTail;
 }

package/dist/index.d.ts

@@ -12,36 +12,41 @@ declare class FastTTLCache {
     /** 存储缓存项的Map */
     private store;
     /** 链表头部指针，指向最久未更新的节点 */
-    head: CacheItem | null;
+    head: CacheItem;
     /** 链表尾部指针，指向最新更新的节点 */
-    tail: CacheItem | null;
+    tail: CacheItem;
     /** 缓存大小 */
     size: number;
+    /** 数据 clone 方法 */
+    private cloneMethod;
     /**
      * 构造函数
-     * @param options 配置选项，包含ttl(过期时间)和capacity(容量)
+     * @param {CacheOptions} options 配置选项，包含ttl(过期时间)和capacity(容量)
      */
     constructor(options?: CacheOptions);
     /**
      * 获取缓存，惰性删除
-     * @param key 缓存键
+     * @param {string} key 缓存键
      * @returns 如果缓存存在且未过期返回值，否则返回null
      */
-    get(key: string): any | null;
+    get(key: string): any;
     /**
      * 设置缓存，包含已存在或新增
-     * @param key 缓存键
-     * @param value 缓存值
+     * @param {string} key 缓存键
+     * @param {any} value 缓存值
      */
     put(key: string, value: any): void;
     /**
      * 移除节点
-     * @param item CacheItem
+     * @param {CacheItem} item
+     * @param {boolean} [isExpire = false] 是否为过期删除
+     * @returns {boolean} 是否删除成功
      */
     private del;
     /**
      * 将节点移动到队尾，队尾的节点一定是最后一个更新的
-     * @param item CacheItem
+     * @param {CacheItem} item
+     * @returns void
      */
     private moveToTail;
 }

package/dist/index.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -14,6 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -22,10 +32,19 @@ __export(index_exports, {
   default: () => FastTTLCache
 });
 module.exports = __toCommonJS(index_exports);
+var import_lodash = __toESM(require("lodash.clonedeep"));
+var import_lodash2 = __toESM(require("lodash.clone"));
+var pure = (i) => i;
+var NO_CLONE = 0;
+var SHALLOW_CLONE = 1;
+var DEEP_CLONE = 2;
+function getCloneMethod(cloneLevel = NO_CLONE) {
+  return cloneLevel === DEEP_CLONE ? import_lodash.default : cloneLevel === SHALLOW_CLONE ? import_lodash2.default : pure;
+}
 var FastTTLCache = class {
   /**
    * 构造函数
-   * @param options 配置选项，包含ttl(过期时间)和capacity(容量)
+   * @param {CacheOptions} options 配置选项，包含ttl(过期时间)和capacity(容量)
    */
   constructor(options = {}) {
     /** 存储缓存项的Map */
@@ -36,8 +55,11 @@ var FastTTLCache = class {
     this.tail = null;
     /** 缓存大小 */
     this.size = 0;
+    /** 数据 clone 方法 */
+    this.cloneMethod = pure;
     this.ttl = options.ttl || Infinity;
     this.capacity = options.capacity || Infinity;
+    this.cloneMethod = getCloneMethod(options.cloneLevel);
     Object.defineProperties(this, {
       size: {
         get() {
@@ -62,36 +84,24 @@ var FastTTLCache = class {
   }
   /**
    * 获取缓存，惰性删除
-   * @param key 缓存键
+   * @param {string} key 缓存键
    * @returns 如果缓存存在且未过期返回值，否则返回null
    */
   get(key) {
     const item = this.store.get(key);
     if (!item) return null;
     if (Date.now() - item.time > this.ttl) {
-      this.del(item);
+      this.del(item, true);
       return null;
     }
-    return item.value;
+    return this.cloneMethod(item.value);
   }
   /**
    * 设置缓存，包含已存在或新增
-   * @param key 缓存键
-   * @param value 缓存值
+   * @param {string} key 缓存键
+   * @param {any} value 缓存值
    */
   put(key, value) {
-    if (this.size === 0) {
-      const item2 = {
-        key,
-        value,
-        prev: null,
-        next: null,
-        time: Date.now()
-      };
-      this.head = this.tail = item2;
-      this.store.set(key, item2);
-      return;
-    }
     if (this.store.has(key)) {
       const item2 = this.store.get(key);
       item2.value = value;
@@ -106,8 +116,12 @@ var FastTTLCache = class {
       next: null,
       time: Date.now()
     };
-    this.tail.next = item;
-    this.tail = item;
+    if (this.size === 0) {
+      this.head = this.tail = item;
+    } else {
+      this.tail.next = item;
+      this.tail = item;
+    }
     this.store.set(key, item);
     if (this.size > this.capacity) {
       this.del(this.head);
@@ -115,16 +129,28 @@ var FastTTLCache = class {
   }
   /**
    * 移除节点
-   * @param item CacheItem
+   * @param {CacheItem} item
+   * @param {boolean} [isExpire = false] 是否为过期删除
+   * @returns {boolean} 是否删除成功
    */
-  del(item) {
+  del(item, isExpire = false) {
     const key = item.key;
     if (!this.store.has(key)) return false;
-    if (this.size === 1) {
-      this.head = this.tail = null;
-    } else if (this.head === item) {
-      this.head = item.next;
-      this.head.prev = null;
+    if (isExpire) {
+      let prevItem = item.prev;
+      while (prevItem) {
+        this.store.delete(prevItem.key);
+        prevItem = prevItem.prev;
+      }
+      this.head = item;
+    }
+    if (this.head === item) {
+      if (item.next) {
+        this.head = item.next;
+        this.head.prev = null;
+      } else {
+        this.head = this.tail = null;
+      }
     } else if (this.tail === item) {
       this.tail = item.prev;
       this.tail.next = null;
@@ -132,12 +158,12 @@ var FastTTLCache = class {
       item.prev.next = item.next;
       item.next.prev = item.prev;
     }
-    this.store.delete(key);
-    return true;
+    return this.store.delete(key);
   }
   /**
    * 将节点移动到队尾，队尾的节点一定是最后一个更新的
-   * @param item CacheItem
+   * @param {CacheItem} item
+   * @returns void
    */
   moveToTail(item) {
     const key = item.key;

package/dist/index.mjs

@@ -1,8 +1,17 @@
 // src/index.ts
+import cloneDeep from "lodash.clonedeep";
+import clone from "lodash.clone";
+var pure = (i) => i;
+var NO_CLONE = 0;
+var SHALLOW_CLONE = 1;
+var DEEP_CLONE = 2;
+function getCloneMethod(cloneLevel = NO_CLONE) {
+  return cloneLevel === DEEP_CLONE ? cloneDeep : cloneLevel === SHALLOW_CLONE ? clone : pure;
+}
 var FastTTLCache = class {
   /**
    * 构造函数
-   * @param options 配置选项，包含ttl(过期时间)和capacity(容量)
+   * @param {CacheOptions} options 配置选项，包含ttl(过期时间)和capacity(容量)
    */
   constructor(options = {}) {
     /** 存储缓存项的Map */
@@ -13,8 +22,11 @@ var FastTTLCache = class {
     this.tail = null;
     /** 缓存大小 */
     this.size = 0;
+    /** 数据 clone 方法 */
+    this.cloneMethod = pure;
     this.ttl = options.ttl || Infinity;
     this.capacity = options.capacity || Infinity;
+    this.cloneMethod = getCloneMethod(options.cloneLevel);
     Object.defineProperties(this, {
       size: {
         get() {
@@ -39,36 +51,24 @@ var FastTTLCache = class {
   }
   /**
    * 获取缓存，惰性删除
-   * @param key 缓存键
+   * @param {string} key 缓存键
    * @returns 如果缓存存在且未过期返回值，否则返回null
    */
   get(key) {
     const item = this.store.get(key);
     if (!item) return null;
     if (Date.now() - item.time > this.ttl) {
-      this.del(item);
+      this.del(item, true);
       return null;
     }
-    return item.value;
+    return this.cloneMethod(item.value);
   }
   /**
    * 设置缓存，包含已存在或新增
-   * @param key 缓存键
-   * @param value 缓存值
+   * @param {string} key 缓存键
+   * @param {any} value 缓存值
    */
   put(key, value) {
-    if (this.size === 0) {
-      const item2 = {
-        key,
-        value,
-        prev: null,
-        next: null,
-        time: Date.now()
-      };
-      this.head = this.tail = item2;
-      this.store.set(key, item2);
-      return;
-    }
     if (this.store.has(key)) {
       const item2 = this.store.get(key);
       item2.value = value;
@@ -83,8 +83,12 @@ var FastTTLCache = class {
       next: null,
       time: Date.now()
     };
-    this.tail.next = item;
-    this.tail = item;
+    if (this.size === 0) {
+      this.head = this.tail = item;
+    } else {
+      this.tail.next = item;
+      this.tail = item;
+    }
     this.store.set(key, item);
     if (this.size > this.capacity) {
       this.del(this.head);
@@ -92,16 +96,28 @@ var FastTTLCache = class {
   }
   /**
    * 移除节点
-   * @param item CacheItem
+   * @param {CacheItem} item
+   * @param {boolean} [isExpire = false] 是否为过期删除
+   * @returns {boolean} 是否删除成功
    */
-  del(item) {
+  del(item, isExpire = false) {
     const key = item.key;
     if (!this.store.has(key)) return false;
-    if (this.size === 1) {
-      this.head = this.tail = null;
-    } else if (this.head === item) {
-      this.head = item.next;
-      this.head.prev = null;
+    if (isExpire) {
+      let prevItem = item.prev;
+      while (prevItem) {
+        this.store.delete(prevItem.key);
+        prevItem = prevItem.prev;
+      }
+      this.head = item;
+    }
+    if (this.head === item) {
+      if (item.next) {
+        this.head = item.next;
+        this.head.prev = null;
+      } else {
+        this.head = this.tail = null;
+      }
     } else if (this.tail === item) {
       this.tail = item.prev;
       this.tail.next = null;
@@ -109,12 +125,12 @@ var FastTTLCache = class {
       item.prev.next = item.next;
       item.next.prev = item.prev;
     }
-    this.store.delete(key);
-    return true;
+    return this.store.delete(key);
   }
   /**
    * 将节点移动到队尾，队尾的节点一定是最后一个更新的
-   * @param item CacheItem
+   * @param {CacheItem} item
+   * @returns void
    */
   moveToTail(item) {
     const key = item.key;

package/dist/types.d.mts

@@ -21,6 +21,8 @@ interface CacheOptions {
     ttl?: number;
     /** 缓存最大容量 */
     capacity?: number;
+    /** 数据 clone 等级，0表示不克隆，1表示浅克隆，2表示深克隆 */
+    cloneLevel?: number;
 }
 
 export type { CacheItem, CacheOptions };

package/dist/types.d.ts

@@ -21,6 +21,8 @@ interface CacheOptions {
     ttl?: number;
     /** 缓存最大容量 */
     capacity?: number;
+    /** 数据 clone 等级，0表示不克隆，1表示浅克隆，2表示深克隆 */
+    cloneLevel?: number;
 }
 
 export type { CacheItem, CacheOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-ttl-cache",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "ttl cache with capacity support use no timer",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -35,5 +35,9 @@
   },
   "files": [
     "dist/"
-  ]
+  ],
+  "dependencies": {
+    "lodash.clone": "^4.5.0",
+    "lodash.clonedeep": "^4.5.0"
+  }
 }