fix(Cache): typescript Map generic type fixed

lib/CacheMapper.ts

@@ -0,0 +1,163 @@
+export class CacheMapper<K, V> implements Map<K, V> {
+  private _innerMap: Map<K, V>;
+  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;
+  }
+
+  apply(id: K, value: unknown) {
+    if (this.has(id)) return this.get(id);
+
+    if (typeof value === 'function') value = value();
+
+    this.set(id, value as V);
+    return value as V;
+  }
+
+  flush() {
+    this._innerMap.clear();
+
+    // set cache size while flusing cache
+    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 this.cache.size;
+  }
+
+  /**
+   * apply cache non-function
+   * @param key cache key string
+   * @param value cache value must same as constructor generic type
+   */
+  apply(key: string, value: V): V;
+
+  /**
+   * apply cache with function
+   * @param key cache key string
+   * @param value cache value must same as constructor generic type
+   */
+  apply(key: string, value: () => V): V;
+
+  /**
+   * apply cache
+   * @param key cache key string
+   * @param value cache value must same as constructor generic type
+   */
+  apply(key: string, value: (() => V) | V) {
+    return this.cache.apply(key, value);
+  }
+  del(key: string) {
+    return this.cache.del(key);
+  }
+  flush() {
+    return this.cache.flush();
+  }
+}

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

@@ -34,7 +34,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,15 @@
 {
   "extends": "hexo/test",
+  "overrides": [
+    {
+      "files": ["*.ts"],
+      "rules": {
+        "node/no-unsupported-features/es-syntax": 0
+      }
+    }
+  ],
   "rules": {
     "@typescript-eslint/no-var-requires": 0,
     "@typescript-eslint/no-empty-function": 0
   }
-}
+}

test/cache.number.test.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
+// mocha --require ts-node/register --exit --grep "Cache - Typescript"
+
+describe('Cache - Typescript', () => {
+  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');
+    });
+
+    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);
+    });
+  });
+});

test/cache.spec.js

@@ -1,63 +1,74 @@
 'use strict';
 
-require('chai').should();
+const chai = require('chai');
+const should = chai.should();
+const expect = chai.expect;
 
 describe('Cache', () => {
+  // const Cache = require('../dist').Cache; // <-- this also works
   const Cache = require('../dist/cache');
   const cache = new Cache();
 
   it('get & set', () => {
     cache.set('foo', 123);
-    cache.get('foo').should.eql(123);
+    should.equal(cache.get('foo'), 123);
   });
 
   it('size', () => {
     cache.set('foobar', 456);
-    cache.size().should.eql(2);
+    should.equal(cache.size(), 2);
   });
 
   it('has', () => {
-    cache.has('foo').should.eql(true);
-    cache.has('bar').should.eql(false);
+    should.equal(cache.has('foo'), true);
+    should.equal(cache.has('bar'), false);
   });
 
   it('apply - non function', () => {
-    cache.apply('bar', 123).should.eql(123);
-    cache.apply('bar', 456).should.eql(123);
-
-    cache.apply('foo', 456).should.eql(123);
+    should.equal(cache.apply('bar', 123), 123);
+    should.equal(cache.apply('bar', 456), 123);
+    should.equal(cache.apply('foo', 456), 123);
   });
 
   it('apply - function', () => {
-    cache.apply('baz', () => 123).should.eql(123);
-    cache.apply('baz', () => 456).should.eql(123);
+    should.equal(
+      cache.apply('baz', () => 123),
+      123
+    );
+    should.equal(
+      cache.apply('baz', () => 456),
+      123
+    );
   });
 
   it('dump', () => {
-    cache.dump().should.eql({
-      'bar': 123,
-      'baz': 123,
-      'foo': 123,
-      'foobar': 456
+    expect(cache.dump()).to.include({
+      bar: 123,
+      baz: 123,
+      foo: 123,
+      foobar: 456
     });
   });
 
   it('del', () => {
     cache.del('baz');
-    cache.has('foo').should.eql(true);
-    cache.has('baz').should.eql(false);
+    should.equal(cache.has('foo'), true);
+    should.equal(cache.has('baz'), false);
   });
 
   it('flush', () => {
     cache.flush();
-    cache.has('foo').should.eql(false);
-    cache.has('bar').should.eql(false);
-    cache.has('baz').should.eql(false);
-    cache.size().should.eql(0);
+    should.equal(cache.has('foo'), false);
+    should.equal(cache.has('bar'), false);
+    should.equal(cache.has('baz'), false);
+    should.equal(cache.size(), 0);
   });
 
   it('cache null', () => {
     cache.apply('foo', null);
-    (cache.apply('foo', 123) === null).should.eql(true);
+    should.equal(cache.apply('foo', 123) === null, true);
   });
+
+  // include typescript test
+  require('./cache.number.test.ts');
 });