Simple TS caching mechanism (use Map instead though...)

cache.ts

type CacheKey = string | number;

interface Cache<T> {
  /** Number of cache entries */
  readonly count: number;
  /** Get an item from the cache */
  get: (key: CacheKey) => T | null;
  /** Check whether cache contains a given item */
  has: (key: CacheKey) => boolean;
  /** Cached items */
  cache: Record<CacheKey, T>;
  /** Remove an item from the cache */
  remove: (key: CacheKey) => void;
  /** Add/set an item in the cache */
  set: (key: CacheKey, item: T) => void;
}

/**
 * Create a cache map structure
 *
 * Use to reduce API calls for potentially duplicate data requests.
 */
export const createCache = <T>(): Cache<T> => {
  const cache: Record<CacheKey, T> = {};

  const get = (key: CacheKey): T | null => {
    return cache[key] ?? null;
  };

  const has = (key: CacheKey) => Boolean(get(key));

  const remove = (key: CacheKey) => {
    delete cache[key];
  };

  const set = (key: CacheKey, item: T) => {
    cache[key] = item;
  };

  return {
    get count() {
      return Object.keys(cache).length;
    },
    cache,
    get,
    has,
    remove,
    set,
  };
};