limited-cache 2.0.0 → 2.1.0

package/dist/limited-cache.esm.js

@@ -1,448 +0,0 @@
-var CURRENT_META_VERSION = 2;
-var MAXIMUM_CACHE_TIME = 365 * 86400 * 1000;
-var defaultOptions = {
-  // Public
-  maxCacheSize: 100,
-  maxCacheTime: 86400 * 1000,
-  // Development-only
-  warnIfItemPurgedBeforeTime: 5000,
-  // Private
-  opLimit: 200,
-  scanLimit: 50
-};
-
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-// To help minification
-var objectCreate = Object.create,
-    objectAssign = Object.assign,
-    hasOwnProperty = Object.prototype.hasOwnProperty;
-var dateNow = Date.now;
-
-/* Initialization and options */
-
-var positiveNumberOrZero = function positiveNumberOrZero(value) {
-  return Math.max(value, 0) || 0;
-};
-
-var normalizeOptions = function normalizeOptions(cacheMetaOptions) {
-  objectAssign(cacheMetaOptions, {
-    maxCacheSize: positiveNumberOrZero(cacheMetaOptions.maxCacheSize),
-    maxCacheTime: positiveNumberOrZero(cacheMetaOptions.maxCacheTime),
-    opLimit: positiveNumberOrZero(cacheMetaOptions.opLimit)
-  });
-
-  if (process.env.NODE_ENV !== 'production') {
-    cacheMetaOptions.warnIfItemPurgedBeforeTime = positiveNumberOrZero(cacheMetaOptions.warnIfItemPurgedBeforeTime);
-  }
-
-  return cacheMetaOptions;
-};
-
-var isCacheMeta = function isCacheMeta(cacheMeta) {
-  return !!cacheMeta && !!cacheMeta.limitedCacheMetaVersion;
-};
-
-var upgradeCacheMeta = function upgradeCacheMeta(cacheMeta) {
-  if (!isCacheMeta(cacheMeta)) {
-    throw new Error('Limited-cache metadata is missing: please check your usage');
-  }
-
-  if (cacheMeta.limitedCacheMetaVersion !== CURRENT_META_VERSION) {
-    // Version is out of date! (Today the only prior version is 1)
-    // Version 1: Cache meta cannot be migrated because timestamps and keys are incompatible
-    console.warn('Limited-cache metadata is from an incompatible version (1). It must be reset.');
-    cacheMeta.limitedCacheMetaVersion = CURRENT_META_VERSION;
-    lowLevelReset(cacheMeta);
-  }
-};
-
-var lowLevelSetOptions = function lowLevelSetOptions(cacheMeta, options) {
-  upgradeCacheMeta(cacheMeta);
-  return normalizeOptions(objectAssign(cacheMeta.options, options));
-};
-
-var lowLevelInit = function lowLevelInit(optionsOrCacheMeta) {
-  if (isCacheMeta(optionsOrCacheMeta)) {
-    var existingCacheMeta = optionsOrCacheMeta;
-    upgradeCacheMeta(existingCacheMeta);
-    return existingCacheMeta;
-  } // Else: it's options
-
-
-  var fullOptions = normalizeOptions(_extends({}, defaultOptions, optionsOrCacheMeta)); // The cacheMeta is created once, and persists per instance
-
-  var newCacheMeta = lowLevelReset({
-    limitedCacheMetaVersion: CURRENT_META_VERSION,
-    options: fullOptions
-  });
-  return newCacheMeta;
-};
-/* Internal cache manipulation */
-
-
-var _getExpireTime = function _getExpireTime(cacheMeta, cacheKey) {
-  var maxCacheTime = cacheMeta.options.maxCacheTime,
-      keyInfo = cacheMeta.keyInfo[cacheKey];
-
-  if (!keyInfo) {
-    // A missing record is always treated as expired
-    return 0;
-  } // If we have an exact expireTime then honor it. Otherwise it'll depend on the current maxCacheTime.
-
-
-  var setTime = keyInfo[0],
-      expireTime = keyInfo[1];
-  return expireTime || setTime + (maxCacheTime || MAXIMUM_CACHE_TIME);
-};
-
-var _cacheKeyHasExpired = function _cacheKeyHasExpired(cacheMeta, cacheKey, now) {
-  return _getExpireTime(cacheMeta, cacheKey) < now;
-};
-
-var lowLevelDoMaintenance = function lowLevelDoMaintenance(cacheMeta) {
-  upgradeCacheMeta(cacheMeta);
-  var cache = cacheMeta.cache,
-      keyList = cacheMeta.keyList,
-      keyInfo = cacheMeta.keyInfo;
-  var now = dateNow(); // Rebuild cache from keyList only, checking timestamps to auto-remove expired
-
-  var _keyList$reduce = keyList.reduce(function (acc, cacheKey) {
-    var accCache = acc[0],
-        accKeyList = acc[1],
-        accKeyInfo = acc[2];
-
-    if (!_cacheKeyHasExpired(cacheMeta, cacheKey, now)) {
-      accCache[cacheKey] = cache[cacheKey];
-      accKeyList.push(cacheKey);
-      accKeyInfo[cacheKey] = keyInfo[cacheKey];
-    }
-
-    return acc;
-  }, [{}, [], objectCreate(null)]),
-      newCache = _keyList$reduce[0],
-      newKeyList = _keyList$reduce[1],
-      newKeyInfo = _keyList$reduce[2];
-
-  return objectAssign(cacheMeta, {
-    cache: newCache,
-    keyList: newKeyList,
-    keyInfo: newKeyInfo,
-    opsLeft: cacheMeta.options.opLimit
-  });
-};
-
-var _removeFromIndex = function _removeFromIndex(cacheMeta, startIndex, now) {
-  var cache = cacheMeta.cache,
-      keyList = cacheMeta.keyList,
-      keyInfo = cacheMeta.keyInfo; // Always remove the item requested, and also remove any neighbors who have expired
-
-  var nextIndex = startIndex;
-  var nextCacheKey = keyList[startIndex];
-  var keyListLength = keyList.length;
-
-  do {
-    // Remove the 'next' item
-    cache[nextCacheKey] = keyInfo[nextCacheKey] = undefined; // Now advance and decide whether to keep going
-
-    nextIndex++;
-    nextCacheKey = keyList[nextIndex];
-  } while (nextIndex < keyListLength && _cacheKeyHasExpired(cacheMeta, nextCacheKey, now)); // Remove the index for everything from the startIndex until we stopped
-
-
-  keyList.splice(startIndex, nextIndex - startIndex);
-};
-
-var _removeItemsToMakeRoom = function _removeItemsToMakeRoom(cacheMeta, now) {
-  var _cacheMeta$options = cacheMeta.options,
-      scanLimit = _cacheMeta$options.scanLimit,
-      warnIfItemPurgedBeforeTime = _cacheMeta$options.warnIfItemPurgedBeforeTime,
-      cache = cacheMeta.cache,
-      keyList = cacheMeta.keyList,
-      keyInfo = cacheMeta.keyInfo; // These track the soonest-to-expire thing we've found. It may not actually be "oldest".
-  // By default we'll remove the item at the head of the queue, unless we find something better.
-
-  var oldestItemIndex = 0;
-
-  var oldestExpireTime = _getExpireTime(cacheMeta, keyList[0]);
-
-  if (oldestExpireTime > now) {
-    // The head of the list hasn't yet expired: scan for a better candidate to remove
-    var indexToCheck = 0;
-    var maxIndexToCheck = Math.min(keyList.length, scanLimit);
-
-    while (indexToCheck < maxIndexToCheck) {
-      var cacheKeyForIndex = keyList[indexToCheck];
-
-      var expireTimeForIndex = _getExpireTime(cacheMeta, cacheKeyForIndex); // We only consider it if it's eligible for expiration: otherwise it can't be a better option
-      // than the default head-of-queue
-
-
-      if (expireTimeForIndex < now) {
-        // We found an expired item! This wins automatically
-        oldestItemIndex = indexToCheck;
-        oldestExpireTime = 0;
-        break;
-      }
-
-      if (expireTimeForIndex < oldestExpireTime) {
-        // We have a new leader
-        oldestItemIndex = indexToCheck;
-        oldestExpireTime = expireTimeForIndex;
-      }
-
-      indexToCheck += 1;
-    }
-  } // Warn if the 'oldest' item is more recent than we'd like: this means it cycled into and out of
-  // cache too quickly for the cache to be useful.
-
-
-  if (process.env.NODE_ENV !== 'production' && warnIfItemPurgedBeforeTime && oldestExpireTime > now) {
-    var oldestItemKey = keyList[oldestItemIndex];
-    var _keyInfo$oldestItemKe = keyInfo[oldestItemKey],
-        oldestItemSetTime = _keyInfo$oldestItemKe[0],
-        oldestItemExpireTime = _keyInfo$oldestItemKe[1];
-
-    if (now - oldestItemSetTime < warnIfItemPurgedBeforeTime) {
-      console.warn('Purged an item from cache while it was still fresh: you may want to increase maxCacheSize', {
-        currentTime: now,
-        key: oldestItemKey,
-        item: cache[oldestItemKey],
-        setTime: oldestItemSetTime,
-        expireTime: oldestItemExpireTime,
-        timeInCache: now - oldestItemSetTime
-      });
-    }
-  } // Remove the oldest item we found, plus any expired neighbors
-
-
-  _removeFromIndex(cacheMeta, oldestItemIndex, now);
-};
-/* Accessors */
-
-
-var lowLevelHas = function lowLevelHas(cacheMeta, cacheKey) {
-  upgradeCacheMeta(cacheMeta);
-  var cache = cacheMeta.cache;
-
-  if (hasOwnProperty.call(cache, cacheKey) && cache[cacheKey] !== undefined) {
-    if (!_cacheKeyHasExpired(cacheMeta, cacheKey, dateNow())) {
-      return true;
-    } // If it's expired, clear the value so that we can short-circuit future lookups
-
-
-    cache[cacheKey] = undefined;
-  }
-
-  return false;
-};
-
-var lowLevelGetOne = function lowLevelGetOne(cacheMeta, cacheKey) {
-  upgradeCacheMeta(cacheMeta);
-
-  if (lowLevelHas(cacheMeta, cacheKey)) {
-    return cacheMeta.cache[cacheKey];
-  }
-
-  return;
-};
-
-var lowLevelGetAll = function lowLevelGetAll(cacheMeta) {
-  upgradeCacheMeta(cacheMeta); // Remove all expired values, and return whatever's left
-
-  lowLevelDoMaintenance(cacheMeta); // Retype because there won't be any `undefined` values after doMaintenance
-
-  return cacheMeta.cache;
-};
-
-var lowLevelSet = function lowLevelSet(cacheMeta, cacheKey, item) {
-  upgradeCacheMeta(cacheMeta);
-  var maxCacheSize = cacheMeta.options.maxCacheSize,
-      keyList = cacheMeta.keyList,
-      keyInfo = cacheMeta.keyInfo;
-  var now = dateNow();
-  var isNew = !keyInfo[cacheKey];
-
-  if (cacheMeta.cache[cacheKey] !== item) {
-    var _extends2;
-
-    // The cache itself is immutable (but the rest of cacheMeta is not)
-    cacheMeta.cache = _extends({}, cacheMeta.cache, (_extends2 = {}, _extends2[cacheKey] = item, _extends2));
-  } // We've now set or updated it. Regardless of whether it's new, bump its set time
-  // @TODO: expireTime override
-
-
-  keyInfo[cacheKey] = [now, 0];
-
-  if (isNew) {
-    // It's a new key: grow the cache, then shrink it if we can
-    keyList.push(cacheKey);
-    cacheMeta.opsLeft--;
-
-    if (cacheMeta.opsLeft <= 0) {
-      // Time for an oil change
-      lowLevelDoMaintenance(cacheMeta);
-    }
-
-    if (maxCacheSize && cacheMeta.keyList.length > maxCacheSize) {
-      // We're still over the limit: drop at least one item
-      _removeItemsToMakeRoom(cacheMeta, now);
-    }
-  }
-
-  if (_cacheKeyHasExpired(cacheMeta, keyList[0], now)) {
-    // While we're here, if we need to expire the head of the queue then drop it
-    _removeFromIndex(cacheMeta, 0, now);
-  }
-
-  return cacheMeta;
-};
-
-var lowLevelRemove = function lowLevelRemove(cacheMeta, cacheKey) {
-  upgradeCacheMeta(cacheMeta);
-  var cache = cacheMeta.cache,
-      keyInfo = cacheMeta.keyInfo;
-
-  if (keyInfo[cacheKey]) {
-    if (cache[cacheKey] !== undefined) {
-      var _extends3;
-
-      cacheMeta.cache = _extends({}, cache, (_extends3 = {}, _extends3[cacheKey] = undefined, _extends3));
-    }
-
-    keyInfo[cacheKey] = undefined;
-  }
-
-  return cacheMeta;
-};
-
-var lowLevelReset = function lowLevelReset(cacheMeta) {
-  upgradeCacheMeta(cacheMeta);
-  return objectAssign(cacheMeta, {
-    cache: {},
-    keyList: [],
-    keyInfo: objectCreate(null),
-    opsLeft: cacheMeta.options.opLimit
-  });
-};
-
-// Doing this via a helper function makes the typeChecks easier, and minifies better.
-
-var bindFunctionToCacheMeta = function bindFunctionToCacheMeta( // eslint-disable-next-line @typescript-eslint/no-explicit-any
-fn, cacheMeta) {
-  return fn.bind(null, cacheMeta);
-};
-
-var LimitedCache = function LimitedCache(options) {
-  var cacheMeta = lowLevelInit(options);
-  return {
-    get: bindFunctionToCacheMeta(lowLevelGetOne, cacheMeta),
-    getAll: bindFunctionToCacheMeta(lowLevelGetAll, cacheMeta),
-    has: bindFunctionToCacheMeta(lowLevelHas, cacheMeta),
-    set: function set(cacheKey, item) {
-      lowLevelSet(cacheMeta, cacheKey, item);
-      return item;
-    },
-    remove: function remove(cacheKey) {
-      lowLevelRemove(cacheMeta, cacheKey);
-      return true;
-    },
-    reset: bindFunctionToCacheMeta(lowLevelReset, cacheMeta),
-    getCacheMeta: function getCacheMeta() {
-      return cacheMeta;
-    },
-    getOptions: function getOptions() {
-      return cacheMeta.options;
-    },
-    setOptions: bindFunctionToCacheMeta(lowLevelSetOptions, cacheMeta),
-    doMaintenance: bindFunctionToCacheMeta(lowLevelDoMaintenance, cacheMeta)
-  };
-};
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-var proxyHandler = {
-  get: function get(cacheMeta, cacheKey) {
-    if (cacheKey === 'hasOwnProperty') {
-      return hasOwnProperty;
-    }
-
-    return lowLevelGetOne(cacheMeta, cacheKey);
-  },
-  getOwnPropertyDescriptor: function getOwnPropertyDescriptor(cacheMeta, cacheKey) {
-    var hasResult = lowLevelHas(cacheMeta, cacheKey);
-    var getResult = lowLevelGetOne(cacheMeta, cacheKey);
-
-    if (hasResult) {
-      return {
-        configurable: true,
-        enumerable: hasResult,
-        value: getResult,
-        writable: true
-      };
-    }
-
-    return;
-  },
-  has: lowLevelHas,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  set: function set(cacheMeta, cacheKey, item) {
-    lowLevelSet(cacheMeta, cacheKey, item);
-    return item;
-  },
-  deleteProperty: function deleteProperty(cacheMeta, cacheKey) {
-    lowLevelRemove(cacheMeta, cacheKey);
-    return true;
-  },
-  ownKeys: function ownKeys(cacheMeta) {
-    return Object.keys(lowLevelGetAll(cacheMeta));
-  }
-};
-/**
- * So that we can retrieve the cacheMeta for a LimitedCacheObject, without polluting its properties, each proxy
- * is associated back to its internal cacheMeta here.
- */
-
-var cacheMetasForProxies = /*#__PURE__*/new WeakMap();
-
-var LimitedCacheObject = function LimitedCacheObject(options) {
-  var cacheMeta = lowLevelInit(options);
-  var limitedCacheObject = new Proxy(cacheMeta, proxyHandler);
-  cacheMetasForProxies.set(limitedCacheObject, cacheMeta);
-  return limitedCacheObject;
-};
-
-var getCacheMetaFromObject = function getCacheMetaFromObject(instance) {
-  return cacheMetasForProxies.get(instance);
-};
-
-var limitedCacheUtil = {
-  init: lowLevelInit,
-  get: lowLevelGetOne,
-  getAll: lowLevelGetAll,
-  has: lowLevelHas,
-  set: lowLevelSet,
-  remove: lowLevelRemove,
-  reset: lowLevelReset,
-  doMaintenance: lowLevelDoMaintenance,
-  setOptions: lowLevelSetOptions
-};
-
-export { CURRENT_META_VERSION, LimitedCache, LimitedCacheObject, MAXIMUM_CACHE_TIME, defaultOptions, getCacheMetaFromObject, isCacheMeta, limitedCacheUtil, lowLevelDoMaintenance, lowLevelGetAll, lowLevelGetOne, lowLevelHas, lowLevelInit, lowLevelRemove, lowLevelReset, lowLevelSet, lowLevelSetOptions, upgradeCacheMeta };
-//# sourceMappingURL=limited-cache.esm.js.map

package/dist/limited-cache.esm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"limited-cache.esm.js","sources":["../src/core/defaultOptions.ts","../src/core/builtIns.ts","../src/core/lowLevelFunctions.ts","../src/core/LimitedCache.ts","../src/core/LimitedCacheObject.ts","../src/core/limitedCacheUtil.ts"],"sourcesContent":["import { LimitedCacheOptionsReadonly } from '../types';\n\nconst CURRENT_META_VERSION = 2;\nconst MAXIMUM_CACHE_TIME = 365 * 86400 * 1000;\n\nconst defaultOptions: LimitedCacheOptionsReadonly = {\n  // Public\n  maxCacheSize: 100,\n  maxCacheTime: 86400 * 1000,\n  // Development-only\n  warnIfItemPurgedBeforeTime: 5000,\n  // Private\n  opLimit: 200,\n  scanLimit: 50,\n};\n\nexport { CURRENT_META_VERSION, MAXIMUM_CACHE_TIME, defaultOptions };\n","// To help minification\nconst {\n  create: objectCreate,\n  assign: objectAssign,\n  prototype: { hasOwnProperty },\n} = Object;\nconst dateNow = Date.now;\n\nexport { objectAssign, objectCreate, dateNow, hasOwnProperty };\n","import { objectAssign, objectCreate, dateNow, hasOwnProperty } from './builtIns';\nimport { CURRENT_META_VERSION, MAXIMUM_CACHE_TIME, defaultOptions } from './defaultOptions';\nimport {\n  LimitedCacheOptions,\n  LimitedCacheOptionsReadonly,\n  LimitedCacheMeta,\n  LimitedCacheOptionsFull,\n  DefaultItemType,\n} from '../types';\n\n/* Initialization and options */\n\nconst positiveNumberOrZero = (value: number): number => Math.max(value, 0) || 0;\n\nconst normalizeOptions = (cacheMetaOptions: LimitedCacheOptionsFull): LimitedCacheOptionsFull => {\n  objectAssign(cacheMetaOptions, {\n    maxCacheSize: positiveNumberOrZero(cacheMetaOptions.maxCacheSize),\n    maxCacheTime: positiveNumberOrZero(cacheMetaOptions.maxCacheTime),\n    opLimit: positiveNumberOrZero(cacheMetaOptions.opLimit),\n  });\n\n  if (process.env.NODE_ENV !== 'production') {\n    cacheMetaOptions.warnIfItemPurgedBeforeTime = positiveNumberOrZero(\n      cacheMetaOptions.warnIfItemPurgedBeforeTime,\n    );\n  }\n  return cacheMetaOptions;\n};\n\nconst isCacheMeta = (cacheMeta: LimitedCacheMeta): boolean => {\n  return !!cacheMeta && !!cacheMeta.limitedCacheMetaVersion;\n};\n\nconst upgradeCacheMeta = (cacheMeta: LimitedCacheMeta): void => {\n  if (!isCacheMeta(cacheMeta)) {\n    throw new Error('Limited-cache metadata is missing: please check your usage');\n  }\n  if (cacheMeta.limitedCacheMetaVersion !== CURRENT_META_VERSION) {\n    // Version is out of date! (Today the only prior version is 1)\n    // Version 1: Cache meta cannot be migrated because timestamps and keys are incompatible\n    console.warn('Limited-cache metadata is from an incompatible version (1). It must be reset.');\n    cacheMeta.limitedCacheMetaVersion = CURRENT_META_VERSION;\n    lowLevelReset(cacheMeta);\n  }\n};\n\nconst lowLevelSetOptions = <ItemType = DefaultItemType>(\n  cacheMeta: LimitedCacheMeta<ItemType>,\n  options: LimitedCacheOptions,\n): LimitedCacheOptionsReadonly => {\n  upgradeCacheMeta(cacheMeta);\n  return normalizeOptions(objectAssign(cacheMeta.options, options));\n};\n\nconst lowLevelInit = <ItemType = DefaultItemType>(\n  optionsOrCacheMeta?: LimitedCacheOptions | LimitedCacheMeta<ItemType>,\n): LimitedCacheMeta<ItemType> => {\n  if (isCacheMeta(optionsOrCacheMeta as LimitedCacheMeta<ItemType>)) {\n    const existingCacheMeta = optionsOrCacheMeta as LimitedCacheMeta<ItemType>;\n    upgradeCacheMeta(existingCacheMeta);\n    return existingCacheMeta;\n  }\n  // Else: it's options\n  const fullOptions = normalizeOptions({ ...defaultOptions, ...optionsOrCacheMeta });\n\n  // The cacheMeta is created once, and persists per instance\n  const newCacheMeta = lowLevelReset({\n    limitedCacheMetaVersion: CURRENT_META_VERSION,\n    options: fullOptions,\n  } as LimitedCacheMeta<ItemType>);\n\n  return newCacheMeta;\n};\n\n/* Internal cache manipulation */\n\nconst _getExpireTime = (cacheMeta: LimitedCacheMeta, cacheKey: string): number => {\n  const {\n    options: { maxCacheTime },\n    keyInfo: { [cacheKey]: keyInfo },\n  } = cacheMeta;\n  if (!keyInfo) {\n    // A missing record is always treated as expired\n    return 0;\n  }\n  // If we have an exact expireTime then honor it. Otherwise it'll depend on the current maxCacheTime.\n  const [setTime, expireTime] = keyInfo;\n  return expireTime || setTime + (maxCacheTime || MAXIMUM_CACHE_TIME);\n};\n\nconst _cacheKeyHasExpired = (\n  cacheMeta: LimitedCacheMeta,\n  cacheKey: string,\n  now: number,\n): boolean => {\n  return _getExpireTime(cacheMeta, cacheKey) < now;\n};\n\nconst lowLevelDoMaintenance = <ItemType = DefaultItemType>(\n  cacheMeta: LimitedCacheMeta<ItemType>,\n): LimitedCacheMeta<ItemType> => {\n  upgradeCacheMeta(cacheMeta);\n  const { cache, keyList, keyInfo } = cacheMeta;\n  const now = dateNow();\n\n  // Rebuild cache from keyList only, checking timestamps to auto-remove expired\n  const [newCache, newKeyList, newKeyInfo] = keyList.reduce(\n    (acc, cacheKey) => {\n      const [accCache, accKeyList, accKeyInfo] = acc;\n      if (!_cacheKeyHasExpired(cacheMeta, cacheKey, now)) {\n        accCache[cacheKey] = cache[cacheKey];\n        accKeyList.push(cacheKey);\n        accKeyInfo[cacheKey] = keyInfo[cacheKey];\n      }\n      return acc;\n    },\n    [\n      {} as typeof cacheMeta['cache'],\n      [] as typeof cacheMeta['keyList'],\n      objectCreate(null) as typeof cacheMeta['keyInfo'],\n    ],\n  );\n\n  return objectAssign(cacheMeta, {\n    cache: newCache,\n    keyList: newKeyList,\n    keyInfo: newKeyInfo,\n    opsLeft: cacheMeta.options.opLimit,\n  });\n};\n\nconst _removeFromIndex = (cacheMeta: LimitedCacheMeta, startIndex: number, now: number): void => {\n  const { cache, keyList, keyInfo } = cacheMeta;\n\n  // Always remove the item requested, and also remove any neighbors who have expired\n  let nextIndex = startIndex;\n  let nextCacheKey = keyList[startIndex];\n  const keyListLength = keyList.length;\n  do {\n    // Remove the 'next' item\n\n    cache[nextCacheKey] = keyInfo[nextCacheKey] = undefined;\n\n    // Now advance and decide whether to keep going\n    nextIndex++;\n    nextCacheKey = keyList[nextIndex];\n  } while (nextIndex < keyListLength && _cacheKeyHasExpired(cacheMeta, nextCacheKey, now));\n\n  // Remove the index for everything from the startIndex until we stopped\n  keyList.splice(startIndex, nextIndex - startIndex);\n};\n\nconst _removeItemsToMakeRoom = (cacheMeta: LimitedCacheMeta, now: number): void => {\n  const {\n    options: { scanLimit, warnIfItemPurgedBeforeTime },\n    cache,\n    keyList,\n    keyInfo,\n  } = cacheMeta;\n\n  // These track the soonest-to-expire thing we've found. It may not actually be \"oldest\".\n  // By default we'll remove the item at the head of the queue, unless we find something better.\n  let oldestItemIndex = 0;\n  let oldestExpireTime = _getExpireTime(cacheMeta, keyList[0]);\n\n  if (oldestExpireTime > now) {\n    // The head of the list hasn't yet expired: scan for a better candidate to remove\n    let indexToCheck = 0;\n    const maxIndexToCheck = Math.min(keyList.length, scanLimit);\n    while (indexToCheck < maxIndexToCheck) {\n      const cacheKeyForIndex = keyList[indexToCheck];\n      let expireTimeForIndex = _getExpireTime(cacheMeta, cacheKeyForIndex);\n\n      // We only consider it if it's eligible for expiration: otherwise it can't be a better option\n      // than the default head-of-queue\n      if (expireTimeForIndex < now) {\n        // We found an expired item! This wins automatically\n        oldestItemIndex = indexToCheck;\n        oldestExpireTime = 0;\n        break;\n      }\n      if (expireTimeForIndex < oldestExpireTime) {\n        // We have a new leader\n        oldestItemIndex = indexToCheck;\n        oldestExpireTime = expireTimeForIndex;\n      }\n      indexToCheck += 1;\n    }\n  }\n\n  // Warn if the 'oldest' item is more recent than we'd like: this means it cycled into and out of\n  // cache too quickly for the cache to be useful.\n  if (\n    process.env.NODE_ENV !== 'production' &&\n    warnIfItemPurgedBeforeTime &&\n    oldestExpireTime > now\n  ) {\n    const oldestItemKey = keyList[oldestItemIndex];\n    const [oldestItemSetTime, oldestItemExpireTime] = keyInfo[oldestItemKey]!;\n\n    if (now - oldestItemSetTime < warnIfItemPurgedBeforeTime) {\n      console.warn(\n        'Purged an item from cache while it was still fresh: you may want to increase maxCacheSize',\n        {\n          currentTime: now,\n          key: oldestItemKey,\n          item: cache[oldestItemKey],\n          setTime: oldestItemSetTime,\n          expireTime: oldestItemExpireTime,\n          timeInCache: now - oldestItemSetTime,\n        },\n      );\n    }\n  }\n\n  // Remove the oldest item we found, plus any expired neighbors\n  _removeFromIndex(cacheMeta, oldestItemIndex, now);\n};\n\n/* Accessors */\n\nconst lowLevelHas = <ItemType = DefaultItemType>(\n  cacheMeta: LimitedCacheMeta<ItemType>,\n  cacheKey: string,\n): boolean => {\n  upgradeCacheMeta(cacheMeta);\n  const { cache } = cacheMeta;\n  if (hasOwnProperty.call(cache, cacheKey) && cache[cacheKey] !== undefined) {\n    if (!_cacheKeyHasExpired(cacheMeta, cacheKey, dateNow())) {\n      return true;\n    }\n    // If it's expired, clear the value so that we can short-circuit future lookups\n    cache[cacheKey] = undefined;\n  }\n  return false;\n};\n\nconst lowLevelGetOne = <ItemType = DefaultItemType>(\n  cacheMeta: LimitedCacheMeta<ItemType>,\n  cacheKey: string,\n): ItemType | undefined => {\n  upgradeCacheMeta(cacheMeta);\n  if (lowLevelHas(cacheMeta, cacheKey)) {\n    return cacheMeta.cache[cacheKey];\n  }\n  return;\n};\n\nconst lowLevelGetAll = <ItemType = DefaultItemType>(\n  cacheMeta: LimitedCacheMeta<ItemType>,\n): Record<string, ItemType> => {\n  upgradeCacheMeta(cacheMeta);\n  // Remove all expired values, and return whatever's left\n  lowLevelDoMaintenance(cacheMeta);\n  // Retype because there won't be any `undefined` values after doMaintenance\n  return cacheMeta.cache as Record<string, ItemType>;\n};\n\nconst lowLevelSet = <ItemType = DefaultItemType>(\n  cacheMeta: LimitedCacheMeta<ItemType>,\n  cacheKey: string,\n  item: ItemType,\n): LimitedCacheMeta<ItemType> => {\n  upgradeCacheMeta(cacheMeta);\n\n  const {\n    options: { maxCacheSize },\n    keyList,\n    keyInfo,\n  } = cacheMeta;\n\n  const now = dateNow();\n  const isNew = !keyInfo[cacheKey];\n\n  if (cacheMeta.cache[cacheKey] !== item) {\n    // The cache itself is immutable (but the rest of cacheMeta is not)\n    cacheMeta.cache = {\n      ...cacheMeta.cache,\n      [cacheKey]: item,\n    };\n  }\n  // We've now set or updated it. Regardless of whether it's new, bump its set time\n  // @TODO: expireTime override\n  keyInfo[cacheKey] = [now, 0];\n\n  if (isNew) {\n    // It's a new key: grow the cache, then shrink it if we can\n    keyList.push(cacheKey);\n\n    cacheMeta.opsLeft--;\n    if (cacheMeta.opsLeft <= 0) {\n      // Time for an oil change\n      lowLevelDoMaintenance(cacheMeta);\n    }\n\n    if (maxCacheSize && cacheMeta.keyList.length > maxCacheSize) {\n      // We're still over the limit: drop at least one item\n      _removeItemsToMakeRoom(cacheMeta, now);\n    }\n  }\n\n  if (_cacheKeyHasExpired(cacheMeta, keyList[0], now)) {\n    // While we're here, if we need to expire the head of the queue then drop it\n    _removeFromIndex(cacheMeta, 0, now);\n  }\n\n  return cacheMeta;\n};\n\nconst lowLevelRemove = <ItemType = DefaultItemType>(\n  cacheMeta: LimitedCacheMeta<ItemType>,\n  cacheKey: string,\n): LimitedCacheMeta<ItemType> => {\n  upgradeCacheMeta(cacheMeta);\n  const { cache, keyInfo } = cacheMeta;\n\n  if (keyInfo[cacheKey]) {\n    if (cache[cacheKey] !== undefined) {\n      cacheMeta.cache = {\n        ...cache,\n        [cacheKey]: undefined,\n      };\n    }\n    keyInfo[cacheKey] = undefined;\n  }\n\n  return cacheMeta;\n};\n\nconst lowLevelReset = <ItemType = DefaultItemType>(\n  cacheMeta: LimitedCacheMeta<ItemType>,\n): LimitedCacheMeta<ItemType> => {\n  upgradeCacheMeta(cacheMeta);\n  return objectAssign(cacheMeta, {\n    cache: {},\n    keyList: [],\n    keyInfo: objectCreate(null),\n    opsLeft: cacheMeta.options.opLimit,\n  });\n};\n\nexport {\n  isCacheMeta,\n  upgradeCacheMeta,\n  lowLevelInit,\n  lowLevelGetOne,\n  lowLevelGetAll,\n  lowLevelHas,\n  lowLevelSet,\n  lowLevelRemove,\n  lowLevelReset,\n  lowLevelDoMaintenance,\n  lowLevelSetOptions,\n};\n","import {\n  lowLevelInit,\n  lowLevelGetOne,\n  lowLevelGetAll,\n  lowLevelHas,\n  lowLevelSet,\n  lowLevelRemove,\n  lowLevelReset,\n  lowLevelSetOptions,\n  lowLevelDoMaintenance,\n} from './lowLevelFunctions';\nimport {\n  LimitedCacheOptions,\n  LimitedCacheOptionsReadonly,\n  LimitedCacheInstance,\n  LimitedCacheMeta,\n  DefaultItemType,\n} from '../types';\n\n// Most public functions just call a low-level function directly, passing the cacheMeta.\n// Doing this via a helper function makes the typeChecks easier, and minifies better.\nconst bindFunctionToCacheMeta = <ItemType>(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  fn: (cacheMeta: LimitedCacheMeta<ItemType>, ...otherArgs: any) => any,\n  cacheMeta: LimitedCacheMeta<ItemType>,\n) => fn.bind(null, cacheMeta);\n\nconst LimitedCache = <ItemType = DefaultItemType>(\n  options?: LimitedCacheOptions,\n): LimitedCacheInstance<ItemType> => {\n  const cacheMeta = lowLevelInit<ItemType>(options);\n\n  return {\n    get: bindFunctionToCacheMeta<ItemType>(lowLevelGetOne, cacheMeta),\n    getAll: bindFunctionToCacheMeta<ItemType>(lowLevelGetAll, cacheMeta),\n    has: bindFunctionToCacheMeta<ItemType>(lowLevelHas, cacheMeta),\n    set: (cacheKey, item): ItemType => {\n      lowLevelSet(cacheMeta, cacheKey, item);\n      return item;\n    },\n    remove: (cacheKey): true => {\n      lowLevelRemove(cacheMeta, cacheKey);\n      return true;\n    },\n    reset: bindFunctionToCacheMeta<ItemType>(lowLevelReset, cacheMeta),\n    getCacheMeta: (): LimitedCacheMeta<ItemType> => cacheMeta,\n    getOptions: (): LimitedCacheOptionsReadonly => cacheMeta.options,\n    setOptions: bindFunctionToCacheMeta<ItemType>(lowLevelSetOptions, cacheMeta),\n    doMaintenance: bindFunctionToCacheMeta<ItemType>(lowLevelDoMaintenance, cacheMeta),\n  };\n};\n\nexport { LimitedCache };\n","import { hasOwnProperty } from './builtIns';\nimport {\n  lowLevelInit,\n  lowLevelGetOne,\n  lowLevelGetAll,\n  lowLevelHas,\n  lowLevelSet,\n  lowLevelRemove,\n} from './lowLevelFunctions';\nimport {\n  LimitedCacheOptions,\n  LimitedCacheObjectInstance,\n  LimitedCacheMeta,\n  DefaultItemType,\n} from '../types';\n\n// The `any` here doesn't escape out anywhere: it's overridden by the constructor below\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst proxyHandler: ProxyHandler<LimitedCacheObjectInstance<any>> = {\n  get: (cacheMeta: LimitedCacheMeta, cacheKey: string) => {\n    if (cacheKey === 'hasOwnProperty') {\n      return hasOwnProperty;\n    }\n    return lowLevelGetOne(cacheMeta, cacheKey);\n  },\n  getOwnPropertyDescriptor: (cacheMeta: LimitedCacheMeta, cacheKey: string) => {\n    const hasResult = lowLevelHas(cacheMeta, cacheKey);\n    const getResult = lowLevelGetOne(cacheMeta, cacheKey);\n\n    if (hasResult) {\n      return {\n        configurable: true,\n        enumerable: hasResult,\n        value: getResult,\n        writable: true,\n      };\n    }\n    return;\n  },\n  has: lowLevelHas,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  set: (cacheMeta: LimitedCacheMeta, cacheKey: string, item: any): any => {\n    lowLevelSet(cacheMeta, cacheKey, item);\n    return item;\n  },\n  deleteProperty: (cacheMeta: LimitedCacheMeta, cacheKey: string): true => {\n    lowLevelRemove(cacheMeta, cacheKey);\n    return true;\n  },\n  ownKeys: (cacheMeta: LimitedCacheMeta) => Object.keys(lowLevelGetAll(cacheMeta)),\n};\n\n/**\n * So that we can retrieve the cacheMeta for a LimitedCacheObject, without polluting its properties, each proxy\n * is associated back to its internal cacheMeta here.\n */\nconst cacheMetasForProxies = new WeakMap();\n\nconst LimitedCacheObject = <ItemType = DefaultItemType>(\n  options?: LimitedCacheOptions,\n): LimitedCacheObjectInstance<ItemType> => {\n  const cacheMeta = lowLevelInit(options);\n  const limitedCacheObject = new Proxy(cacheMeta, proxyHandler);\n\n  cacheMetasForProxies.set(limitedCacheObject, cacheMeta);\n  return limitedCacheObject;\n};\n\nconst getCacheMetaFromObject = (instance: LimitedCacheObjectInstance): LimitedCacheMeta => {\n  return cacheMetasForProxies.get(instance);\n};\n\nexport { LimitedCacheObject, getCacheMetaFromObject };\n","import {\n  lowLevelGetOne,\n  lowLevelGetAll,\n  lowLevelHas,\n  lowLevelInit,\n  lowLevelDoMaintenance,\n  lowLevelRemove,\n  lowLevelReset,\n  lowLevelSet,\n  lowLevelSetOptions,\n} from './lowLevelFunctions';\n\nconst limitedCacheUtil = {\n  init: lowLevelInit,\n  get: lowLevelGetOne,\n  getAll: lowLevelGetAll,\n  has: lowLevelHas,\n  set: lowLevelSet,\n  remove: lowLevelRemove,\n  reset: lowLevelReset,\n  doMaintenance: lowLevelDoMaintenance,\n  setOptions: lowLevelSetOptions,\n};\n\nexport { limitedCacheUtil };\n"],"names":["CURRENT_META_VERSION","MAXIMUM_CACHE_TIME","defaultOptions","maxCacheSize","maxCacheTime","warnIfItemPurgedBeforeTime","opLimit","scanLimit","objectCreate","Object","create","objectAssign","assign","hasOwnProperty","prototype","dateNow","Date","now","positiveNumberOrZero","value","Math","max","normalizeOptions","cacheMetaOptions","process","env","NODE_ENV","isCacheMeta","cacheMeta","limitedCacheMetaVersion","upgradeCacheMeta","Error","console","warn","lowLevelReset","lowLevelSetOptions","options","lowLevelInit","optionsOrCacheMeta","existingCacheMeta","fullOptions","newCacheMeta","_getExpireTime","cacheKey","keyInfo","setTime","expireTime","_cacheKeyHasExpired","lowLevelDoMaintenance","cache","keyList","reduce","acc","accCache","accKeyList","accKeyInfo","push","newCache","newKeyList","newKeyInfo","opsLeft","_removeFromIndex","startIndex","nextIndex","nextCacheKey","keyListLength","length","undefined","splice","_removeItemsToMakeRoom","oldestItemIndex","oldestExpireTime","indexToCheck","maxIndexToCheck","min","cacheKeyForIndex","expireTimeForIndex","oldestItemKey","oldestItemSetTime","oldestItemExpireTime","currentTime","key","item","timeInCache","lowLevelHas","call","lowLevelGetOne","lowLevelGetAll","lowLevelSet","isNew","lowLevelRemove","bindFunctionToCacheMeta","fn","bind","LimitedCache","get","getAll","has","set","remove","reset","getCacheMeta","getOptions","setOptions","doMaintenance","proxyHandler","getOwnPropertyDescriptor","hasResult","getResult","configurable","enumerable","writable","deleteProperty","ownKeys","keys","cacheMetasForProxies","WeakMap","LimitedCacheObject","limitedCacheObject","Proxy","getCacheMetaFromObject","instance","limitedCacheUtil","init"],"mappings":"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"}

package/legacy-types/ts3.x/dist/core/LimitedCache.d.ts

@@ -1,3 +0,0 @@
-import { LimitedCacheInstance } from '../types';
-declare const LimitedCache: <ItemType = any>(options?: Partial<import("../types").LimitedCacheOptionsFull> | null | undefined) => LimitedCacheInstance<ItemType>;
-export { LimitedCache };

package/legacy-types/ts3.x/dist/core/LimitedCacheObject.d.ts

@@ -1,4 +0,0 @@
-import { LimitedCacheObjectInstance, LimitedCacheMeta } from '../types';
-declare const LimitedCacheObject: <ItemType = any>(options?: Partial<import("../types").LimitedCacheOptionsFull> | null | undefined) => LimitedCacheObjectInstance<ItemType>;
-declare const getCacheMetaFromObject: (instance: LimitedCacheObjectInstance) => LimitedCacheMeta;
-export { LimitedCacheObject, getCacheMetaFromObject };

package/legacy-types/ts3.x/dist/core/builtIns.d.ts

@@ -1,11 +0,0 @@
-declare const objectCreate: {
-    (o: object | null): any;
-    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
-}, objectAssign: {
-    <T, U>(target: T, source: U): T & U;
-    <T_1, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
-    <T_2, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
-    (target: object, ...sources: any[]): any;
-}, hasOwnProperty: (v: string | number | symbol) => boolean;
-declare const dateNow: () => number;
-export { objectAssign, objectCreate, dateNow, hasOwnProperty };

package/legacy-types/ts3.x/dist/core/defaultOptions.d.ts

@@ -1,5 +0,0 @@
-import { LimitedCacheOptionsReadonly } from '../types';
-declare const CURRENT_META_VERSION = 2;
-declare const MAXIMUM_CACHE_TIME: number;
-declare const defaultOptions: LimitedCacheOptionsReadonly;
-export { CURRENT_META_VERSION, MAXIMUM_CACHE_TIME, defaultOptions };

package/legacy-types/ts3.x/dist/core/limitedCacheUtil.d.ts

@@ -1,12 +0,0 @@
-declare const limitedCacheUtil: {
-    init: <ItemType = any>(optionsOrCacheMeta?: Partial<import("..").LimitedCacheOptionsFull> | import("..").LimitedCacheMeta<ItemType> | null | undefined) => import("..").LimitedCacheMeta<ItemType>;
-    get: <ItemType_1 = any>(cacheMeta: import("..").LimitedCacheMeta<ItemType_1>, cacheKey: string) => ItemType_1 | undefined;
-    getAll: <ItemType_2 = any>(cacheMeta: import("..").LimitedCacheMeta<ItemType_2>) => Record<string, ItemType_2>;
-    has: <ItemType_3 = any>(cacheMeta: import("..").LimitedCacheMeta<ItemType_3>, cacheKey: string) => boolean;
-    set: <ItemType_4 = any>(cacheMeta: import("..").LimitedCacheMeta<ItemType_4>, cacheKey: string, item: ItemType_4) => import("..").LimitedCacheMeta<ItemType_4>;
-    remove: <ItemType_5 = any>(cacheMeta: import("..").LimitedCacheMeta<ItemType_5>, cacheKey: string) => import("..").LimitedCacheMeta<ItemType_5>;
-    reset: <ItemType_6 = any>(cacheMeta: import("..").LimitedCacheMeta<ItemType_6>) => import("..").LimitedCacheMeta<ItemType_6>;
-    doMaintenance: <ItemType_7 = any>(cacheMeta: import("..").LimitedCacheMeta<ItemType_7>) => import("..").LimitedCacheMeta<ItemType_7>;
-    setOptions: <ItemType_8 = any>(cacheMeta: import("..").LimitedCacheMeta<ItemType_8>, options: import("..").LimitedCacheOptions) => Readonly<import("..").LimitedCacheOptionsFull>;
-};
-export { limitedCacheUtil };

package/legacy-types/ts3.x/dist/core/lowLevelFunctions.d.ts

@@ -1,13 +0,0 @@
-import { LimitedCacheOptions, LimitedCacheOptionsReadonly, LimitedCacheMeta, LimitedCacheOptionsFull } from '../types';
-declare const isCacheMeta: (cacheMeta: LimitedCacheMeta) => boolean;
-declare const upgradeCacheMeta: (cacheMeta: LimitedCacheMeta) => void;
-declare const lowLevelSetOptions: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>, options: LimitedCacheOptions) => LimitedCacheOptionsReadonly;
-declare const lowLevelInit: <ItemType = any>(optionsOrCacheMeta?: Partial<LimitedCacheOptionsFull> | LimitedCacheMeta<ItemType> | null | undefined) => LimitedCacheMeta<ItemType>;
-declare const lowLevelDoMaintenance: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>) => LimitedCacheMeta<ItemType>;
-declare const lowLevelHas: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => boolean;
-declare const lowLevelGetOne: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => ItemType | undefined;
-declare const lowLevelGetAll: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>) => Record<string, ItemType>;
-declare const lowLevelSet: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string, item: ItemType) => LimitedCacheMeta<ItemType>;
-declare const lowLevelRemove: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>, cacheKey: string) => LimitedCacheMeta<ItemType>;
-declare const lowLevelReset: <ItemType = any>(cacheMeta: LimitedCacheMeta<ItemType>) => LimitedCacheMeta<ItemType>;
-export { isCacheMeta, upgradeCacheMeta, lowLevelInit, lowLevelGetOne, lowLevelGetAll, lowLevelHas, lowLevelSet, lowLevelRemove, lowLevelReset, lowLevelDoMaintenance, lowLevelSetOptions, };

package/legacy-types/ts3.x/dist/index.d.ts

@@ -1,6 +0,0 @@
-export * from './core/defaultOptions';
-export * from './core/LimitedCache';
-export * from './core/LimitedCacheObject';
-export * from './core/limitedCacheUtil';
-export * from './core/lowLevelFunctions';
-export * from './types';

package/legacy-types/ts3.x/dist/types.d.ts

@@ -1,60 +0,0 @@
-export declare type DefaultItemType = any;
-export interface LimitedCacheOptionsFull {
-    /** Items will be removed to keep the cache within the maxCacheSize limit */
-    maxCacheSize: number;
-    /** Items will be removed and never returned if they were set more than maxCacheTime milliseconds ago */
-    maxCacheTime: number;
-    /** (dev only) A warning will be emitted if an item rotates out of the cache before this many milliseconds have passed, to indicate the size is too small */
-    warnIfItemPurgedBeforeTime: number;
-    /** (private) Internal cleanup of old keys will be performed after this many operations */
-    opLimit: number;
-    /** (private) Internal optimization to adjust how much searching will be done to find expired items, to avoid being O(n) */
-    scanLimit: number;
-}
-export declare type LimitedCacheOptions = Partial<LimitedCacheOptionsFull> | null;
-export declare type LimitedCacheOptionsReadonly = Readonly<LimitedCacheOptionsFull>;
-export interface LimitedCacheInstance<ItemType = DefaultItemType> {
-    /** Return the requested item, if it has not expired */
-    get: (cacheKey: string) => ItemType | undefined;
-    /** Return all non-expired items */
-    getAll: () => Record<string, ItemType>;
-    /** Indicate whether or not the requested item is present and has not expired */
-    has: (cacheKey: string) => boolean;
-    /** Add the item to the cache, or update its timestamp if it already exists */
-    set: (cacheKey: string, item: ItemType) => ItemType;
-    /** Remove the requested item from the cache, if necessary */
-    remove: (cacheKey: string) => true;
-    /** Remove all items and all timestamps from the cache */
-    reset: () => LimitedCacheMeta<ItemType>;
-    /** Return a serializable representation of the cache internals, suitable for long-term storage */
-    getCacheMeta: () => LimitedCacheMeta<ItemType>;
-    /** Return the cache's current values for all options */
-    getOptions: () => LimitedCacheOptionsFull;
-    /** Update one or more of the cache's options */
-    setOptions: (newOptions: LimitedCacheOptions) => LimitedCacheOptionsReadonly;
-    /** Reduces cache size by cleaning up old keys and expired items */
-    doMaintenance: () => LimitedCacheMeta<ItemType>;
-}
-export interface LimitedCacheObjectInstance<ItemType = DefaultItemType> {
-    [key: string]: ItemType;
-}
-/**
- *  A serializable representation of the cache internals, suitable for long-term storage
- */
-export interface LimitedCacheMeta<ItemType = DefaultItemType> {
-    /** Schema version: old versions will be upgraded if possible, or a warning will be emitted if not */
-    limitedCacheMetaVersion: number;
-    /** Options to control cache size, time, and behavior */
-    options: LimitedCacheOptionsReadonly;
-    /** The values in the cache, stored by key. Will include old keys not yet garbage collected */
-    cache: Record<string, ItemType | undefined>;
-    /** List of keys that have been set, in chronological order. Used to find cache items most likely to be expired */
-    keyList: Array<string>;
-    /** The [setTime, expirationTime] for each key that has been set. Removed on unset. */
-    keyInfo: Record<string, [
-        number,
-        number
-    ] | undefined>;
-    /** Number of operations remaining until internal cleanup of old keys is performed. Based on options.opLimit */
-    opsLeft: number;
-}