Class LruCache

cache/lru_cache.ts:98–362

 * ```
 */
export class LruCache<K, V> extends Map<K, V>
  implements MemoizationCache<K, V> {
  #maxSize: number;
  #ejecting = false;
  #eject?:
    | ((ejectedKey: K, ejectedValue: V, reason: LruCacheEjectionReason) => void)
    | undefined;

  /**
   * Constructs a new `LruCache`.
   *
   * @experimental **UNSTABLE**: New API, yet to be vetted.
   *
   * @param maxSize The maximum number of entries to store in the cache. Must
   * be a positive integer.
   * @param options Additional options.
   */
  constructor(
    maxSize: number,
    options?: LruCacheOptions<K, V>,
  ) {
    super();
    if (!Number.isInteger(maxSize) || maxSize < 1) {
      throw new RangeError(
        `Cannot create LruCache: maxSize must be a positive integer: received ${maxSize}`,
      );
    }
    this.#maxSize = maxSize;
    this.#eject = options?.onEject;
  }

  /**
   * The maximum number of entries to store in the cache.
   *
   * @returns The maximum number of entries in the cache.
   *
   * @example Max size
   * ```ts
   * import { LruCache } from "@std/cache";
   * import { assertEquals } from "@std/assert";
   *
   * const cache = new LruCache<string, number>(100);
   * assertEquals(cache.maxSize, 100);
   * ```
   */
  get maxSize(): number {
    return this.#maxSize;
  }

  #setMostRecentlyUsed(key: K, value: V): void {
    super.delete(key);
    super.set(key, value);
  }

  #pruneToMaxSize(): void {
    if (this.size <= this.#maxSize) return;
    const key = this.keys().next().value!;
    const value = super.get(key)!;