fix(Cache): typescript Map generic type fixed

lib/CacheMapper.ts

@@ -0,0 +1,161 @@
+/** @internal */
+export class CacheMapper<K, V> implements Map<K, V> {
+  private readonly _innerMap: Map<K, V>;
+  readonly size: number;
+
+  constructor() {
+    this._innerMap = new Map();
+  }
+  clear(): void {
+    this._innerMap.clear();
+  }
+  delete(key: K): boolean {
+    throw this._innerMap.delete(key);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void {
+    return this._innerMap.forEach(callbackfn, thisArg);
+  }
+  entries(): IterableIterator<[K, V]> {
+    return this._innerMap.entries();
+  }
+  keys(): IterableIterator<K> {
+    return this._innerMap.keys();
+  }
+  values(): IterableIterator<V> {
+    return this._innerMap.values();
+  }
+  [Symbol.iterator](): IterableIterator<[K, V]> {
+    return this._innerMap.entries();
+  }
+  [Symbol.toStringTag]: string;
+
+  typeof() {
+    return typeof this._innerMap;
+  }
+
+  set(id: K, value: V) {
+    this._innerMap.set(id, value);
+    // set cache size while set new value
+    // this.size = this._innerMap.size;
+    return this;
+  }
+
+  has(id: K) {
+    return this._innerMap.has(id);
+  }
+
+  get(id: K) {
+    return this._innerMap.get(id);
+  }
+
+  del(id: K) {
+    this._innerMap.delete(id);
+    // set cache size while delete value
+    // this.size = this._innerMap.size;
+  }
+}
+
+/**
+ * Generic Mutable Cache with `Map`
+ * * A Map holds key-value pairs where the keys can be any datatype (Generic)
+ * @example
+ * import { Cache } from 'hexo-util';
+ * const c = new Cache<number>();
+ * // error
+ * c.set('key', 'xxxx'); // cache value must be instance of number
+ * // pass
+ * c.set('key', 1);
+ */
+export class Cache<V> {
+  private cache: CacheMapper<string, V>;
+  constructor() {
+    this.cache = new CacheMapper<string, V>();
+  }
+
+  /**
+   * check cache is exist with given key
+   * @param key cache key string
+   * @returns
+   */
+  has(key: string) {
+    return this.cache.has(key);
+  }
+
+  /**
+   * get cache
+   * @param key
+   * @returns
+   */
+  get(key: string) {
+    return this.cache.get(key);
+  }
+
+  /**
+   * set cache
+   * @param key
+   * @param value cache value must same as constructor generic type
+   * @returns
+   */
+  set(key: string, value: V) {
+    return this.cache.set(key, value);
+  }
+
+  /**
+   * dump cache
+   * @returns
+   */
+  dump() {
+    return Object.fromEntries(this.cache);
+  }
+
+  /**
+   * get cache total
+   * @returns
+   */
+  size() {
+    return Array.from(this.cache.keys()).length;
+  }
+
+  /**
+   * cacheable setter non-function
+   * * new value will never updated when previous key already exist
+   * @param key cache key string
+   * @param value cache value must same as constructor generic type
+   */
+  apply(key: string, value: V): V;
+
+  /**
+   * cacheable setter with function
+   * * new value will never updated when previous key already exist
+   * @param key cache key string
+   * @param value cache value must same as constructor generic type
+   */
+  apply(key: string, value: () => V): V;
+
+  /**
+   * cacheable setter
+   * * new value will never updated when previous key already exist
+   * @param key cache key string
+   * @param value cache value must same as constructor generic type
+   */
+  apply(id: string, value: V & (() => V)) {
+    if (this.has(id)) return this.get(id);
+    let newValue: V;
+    if (typeof value === 'function') {
+      newValue = value();
+    } else {
+      newValue = value;
+    }
+
+    this.cache.set(id, newValue);
+    return newValue;
+  }
+
+  del(key: string) {
+    return this.cache.del(key);
+  }
+  flush() {
+    this.cache.clear();
+  }
+}

lib/cache.ts

@@ -1,44 +1,3 @@
-export = class Cache<T> {
-  cache: Map<string, T>;
+import { Cache } from './CacheMapper';
 
-  constructor() {
-    this.cache = new Map();
-  }
-
-  set(id: string, value: T) {
-    this.cache.set(id, value);
-  }
-
-  has(id: string) {
-    return this.cache.has(id);
-  }
-
-  get(id: string) {
-    return this.cache.get(id);
-  }
-
-  del(id: string) {
-    this.cache.delete(id);
-  }
-
-  apply(id: string, value): T {
-    if (this.has(id)) return this.get(id);
-
-    if (typeof value === 'function') value = value();
-
-    this.set(id, value);
-    return value;
-  }
-
-  flush() {
-    this.cache.clear();
-  }
-
-  size() {
-    return this.cache.size;
-  }
-
-  dump() {
-    return Object.fromEntries(this.cache);
-  }
-};
+export = Cache;

package.json

@@ -13,6 +13,7 @@
     "pretest": "npm run clean && npm run build",
     "test": "mocha --require ts-node/register",
     "test-cov": "nyc --reporter=lcovonly npm run test",
+    "test-single": "npm run pretest && mocha --require ts-node/register --exit --grep",
     "build:highlight": "node scripts/build_highlight_alias.js",
     "postinstall": "npm run build:highlight"
   },
@@ -34,7 +35,9 @@
   ],
   "license": "MIT",
   "devDependencies": {
+    "@types/chai": "^4.3.5",
     "@types/cross-spawn": "^6.0.2",
+    "@types/mocha": "^10.0.1",
     "@types/node": "^18.11.8",
     "@types/prismjs": "^1.26.0",
     "@typescript-eslint/eslint-plugin": "^5.41.0",

test/.eslintrc.json

@@ -1,7 +1,16 @@
 {
   "extends": "hexo/test",
+  "overrides": [
+    {
+      "files": ["*.ts"],
+      "rules": {
+        "node/no-unsupported-features/es-syntax": 0,
+        "@typescript-eslint/no-non-null-assertion": 0
+      }
+    }
+  ],
   "rules": {
     "@typescript-eslint/no-var-requires": 0,
     "@typescript-eslint/no-empty-function": 0
   }
-}
+}

test/cache-number.spec.ts

@@ -0,0 +1,49 @@
+'use strict';
+
+import { describe, it } from 'mocha';
+import * as Hutil from '../lib';
+import { expect } from 'chai';
+
+// to run single test
+// npm run test-single -- "Cache - number"
+
+describe('Cache - number', () => {
+  const cache = new Hutil.Cache<number>();
+  const dumpExpect = { foo: 1, bar: 2 };
+
+  it('should be number', () => {
+    // apply non-function
+    expect(cache.apply('foo', 1)).to.be.an('number');
+    // apply with function
+    expect(cache.apply('bar', () => 2)).to.be.an('number');
+    // validate cache exist
+    expect(cache.has('foo') && cache.has('bar')).to.be.true;
+  });
+
+  it('add another and delete it', () => {
+    // add `another`
+    expect(cache.apply('another', 3)).to.equal(3);
+    // size should be 3
+    expect(cache.size()).to.equal(3);
+    // add with function
+    expect(cache.apply('another', () => 3)).to.equal(3);
+    // size should be still 3
+    expect(cache.size()).to.equal(3);
+    // delete `another`
+    cache.del('another');
+  });
+
+  it('final size should be 2', () => {
+    // final size should be 2
+    expect(cache.size()).to.equal(2);
+  });
+
+  it('should dump matches', () => {
+    expect(cache.dump()).deep.equal(dumpExpect);
+  });
+
+  it('should be empty after flush', () => {
+    cache.flush();
+    expect(cache.size()).to.be.equal(0);
+  });
+});