limited-cache 2.1.1 → 2.3.0

package/dist/esm/index.js

@@ -0,0 +1,280 @@
+//#region src/core/defaultOptions.ts
+const CURRENT_META_VERSION = 2;
+const MAXIMUM_CACHE_TIME = 365 * 86400 * 1e3;
+const defaultOptions = {
+	maxCacheSize: 100,
+	maxCacheTime: 86400 * 1e3,
+	warnIfItemPurgedBeforeTime: 5e3,
+	opLimit: 200,
+	scanLimit: 50
+};
+//#endregion
+//#region src/core/lowLevelFunctions.ts
+const positiveNumberOrZero = (value) => Math.max(value, 0) || 0;
+const normalizeOptions = (cacheMetaOptions) => {
+	Object.assign(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;
+};
+const isCacheMeta = (cacheMeta) => {
+	return !!cacheMeta?.limitedCacheMetaVersion;
+};
+const upgradeCacheMeta = (cacheMeta) => {
+	if (!isCacheMeta(cacheMeta)) throw new Error("Limited-cache metadata is missing: please check your usage");
+	if (cacheMeta.limitedCacheMetaVersion !== 2) {
+		console.warn("Limited-cache metadata is from an incompatible version (1). It must be reset.");
+		cacheMeta.limitedCacheMetaVersion = 2;
+		lowLevelReset(cacheMeta);
+	}
+};
+const lowLevelSetOptions = (cacheMeta, options) => {
+	upgradeCacheMeta(cacheMeta);
+	return normalizeOptions(Object.assign(cacheMeta.options, options));
+};
+const lowLevelInit = (optionsOrCacheMeta) => {
+	if (isCacheMeta(optionsOrCacheMeta)) {
+		const existingCacheMeta = optionsOrCacheMeta;
+		upgradeCacheMeta(existingCacheMeta);
+		return existingCacheMeta;
+	}
+	return lowLevelReset({
+		limitedCacheMetaVersion: 2,
+		options: normalizeOptions({
+			...defaultOptions,
+			...optionsOrCacheMeta
+		})
+	});
+};
+const _getExpireTime = (cacheMeta, cacheKey) => {
+	const { options: { maxCacheTime }, keyInfo: { [cacheKey]: keyInfo } } = cacheMeta;
+	if (!keyInfo) return 0;
+	const [setTime, expireTime] = keyInfo;
+	return expireTime || setTime + (maxCacheTime || 31536e6);
+};
+const _cacheKeyHasExpired = (cacheMeta, cacheKey, now) => {
+	return _getExpireTime(cacheMeta, cacheKey) < now;
+};
+const lowLevelDoMaintenance = (cacheMeta) => {
+	upgradeCacheMeta(cacheMeta);
+	const { cache, keyList, keyInfo } = cacheMeta;
+	const now = Date.now();
+	const [newCache, newKeyList, newKeyInfo] = keyList.reduce((acc, cacheKey) => {
+		const [accCache, accKeyList, accKeyInfo] = acc;
+		if (!_cacheKeyHasExpired(cacheMeta, cacheKey, now)) {
+			accCache[cacheKey] = cache[cacheKey];
+			accKeyList.push(cacheKey);
+			accKeyInfo[cacheKey] = keyInfo[cacheKey];
+		}
+		return acc;
+	}, [
+		{},
+		[],
+		Object.create(null)
+	]);
+	return Object.assign(cacheMeta, {
+		cache: newCache,
+		keyList: newKeyList,
+		keyInfo: newKeyInfo,
+		opsLeft: cacheMeta.options.opLimit
+	});
+};
+const _removeFromIndex = (cacheMeta, startIndex, now) => {
+	const { cache, keyList, keyInfo } = cacheMeta;
+	let nextIndex = startIndex;
+	let nextCacheKey = keyList[startIndex];
+	const keyListLength = keyList.length;
+	do {
+		cache[nextCacheKey] = keyInfo[nextCacheKey] = void 0;
+		nextIndex++;
+		nextCacheKey = keyList[nextIndex];
+	} while (nextIndex < keyListLength && _cacheKeyHasExpired(cacheMeta, nextCacheKey, now));
+	keyList.splice(startIndex, nextIndex - startIndex);
+};
+const _removeItemsToMakeRoom = (cacheMeta, now) => {
+	const { options: { scanLimit, warnIfItemPurgedBeforeTime }, cache, keyList, keyInfo } = cacheMeta;
+	let oldestItemIndex = 0;
+	let oldestExpireTime = _getExpireTime(cacheMeta, keyList[0]);
+	if (oldestExpireTime > now) {
+		let indexToCheck = 0;
+		const maxIndexToCheck = Math.min(keyList.length, scanLimit);
+		while (indexToCheck < maxIndexToCheck) {
+			const cacheKeyForIndex = keyList[indexToCheck];
+			const expireTimeForIndex = _getExpireTime(cacheMeta, cacheKeyForIndex);
+			if (expireTimeForIndex < now) {
+				oldestItemIndex = indexToCheck;
+				oldestExpireTime = 0;
+				break;
+			}
+			if (expireTimeForIndex < oldestExpireTime) {
+				oldestItemIndex = indexToCheck;
+				oldestExpireTime = expireTimeForIndex;
+			}
+			indexToCheck += 1;
+		}
+	}
+	if (process.env.NODE_ENV !== "production" && warnIfItemPurgedBeforeTime && oldestExpireTime > now) {
+		const oldestItemKey = keyList[oldestItemIndex];
+		const [oldestItemSetTime, oldestItemExpireTime] = keyInfo[oldestItemKey];
+		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
+		});
+	}
+	_removeFromIndex(cacheMeta, oldestItemIndex, now);
+};
+const lowLevelHas = (cacheMeta, cacheKey) => {
+	upgradeCacheMeta(cacheMeta);
+	const { cache } = cacheMeta;
+	if (Object.prototype.hasOwnProperty.call(cache, cacheKey) && cache[cacheKey] !== void 0) {
+		if (!_cacheKeyHasExpired(cacheMeta, cacheKey, Date.now())) return true;
+		cache[cacheKey] = void 0;
+	}
+	return false;
+};
+const lowLevelGetOne = (cacheMeta, cacheKey) => {
+	upgradeCacheMeta(cacheMeta);
+	if (lowLevelHas(cacheMeta, cacheKey)) return cacheMeta.cache[cacheKey];
+};
+const lowLevelGetAll = (cacheMeta) => {
+	upgradeCacheMeta(cacheMeta);
+	lowLevelDoMaintenance(cacheMeta);
+	return cacheMeta.cache;
+};
+const lowLevelSet = (cacheMeta, cacheKey, item) => {
+	upgradeCacheMeta(cacheMeta);
+	const { options: { maxCacheSize }, keyList, keyInfo } = cacheMeta;
+	const now = Date.now();
+	const isNew = !keyInfo[cacheKey];
+	if (cacheMeta.cache[cacheKey] !== item) cacheMeta.cache = {
+		...cacheMeta.cache,
+		[cacheKey]: item
+	};
+	keyInfo[cacheKey] = [now, 0];
+	if (isNew) {
+		keyList.push(cacheKey);
+		cacheMeta.opsLeft--;
+		if (cacheMeta.opsLeft <= 0) lowLevelDoMaintenance(cacheMeta);
+		if (maxCacheSize && cacheMeta.keyList.length > maxCacheSize) _removeItemsToMakeRoom(cacheMeta, now);
+	}
+	if (_cacheKeyHasExpired(cacheMeta, keyList[0], now)) _removeFromIndex(cacheMeta, 0, now);
+	return cacheMeta;
+};
+const lowLevelRemove = (cacheMeta, cacheKey) => {
+	upgradeCacheMeta(cacheMeta);
+	const { cache, keyInfo } = cacheMeta;
+	if (keyInfo[cacheKey]) {
+		if (cache[cacheKey] !== void 0) cacheMeta.cache = {
+			...cache,
+			[cacheKey]: void 0
+		};
+		keyInfo[cacheKey] = void 0;
+	}
+	return cacheMeta;
+};
+const lowLevelReset = (cacheMeta) => {
+	upgradeCacheMeta(cacheMeta);
+	return Object.assign(cacheMeta, {
+		cache: {},
+		keyList: [],
+		keyInfo: Object.create(null),
+		opsLeft: cacheMeta.options.opLimit
+	});
+};
+//#endregion
+//#region src/core/LimitedCache.ts
+const bindFunctionToCacheMeta = (fn, cacheMeta) => fn.bind(null, cacheMeta);
+const LimitedCache = (options) => {
+	const cacheMeta = lowLevelInit(options);
+	return {
+		get: bindFunctionToCacheMeta(lowLevelGetOne, cacheMeta),
+		getAll: bindFunctionToCacheMeta(lowLevelGetAll, cacheMeta),
+		has: bindFunctionToCacheMeta(lowLevelHas, cacheMeta),
+		set: (cacheKey, item) => {
+			lowLevelSet(cacheMeta, cacheKey, item);
+			return item;
+		},
+		remove: (cacheKey) => {
+			lowLevelRemove(cacheMeta, cacheKey);
+			return true;
+		},
+		reset: bindFunctionToCacheMeta(lowLevelReset, cacheMeta),
+		getCacheMeta: () => cacheMeta,
+		getOptions: () => cacheMeta.options,
+		setOptions: bindFunctionToCacheMeta(lowLevelSetOptions, cacheMeta),
+		doMaintenance: bindFunctionToCacheMeta(lowLevelDoMaintenance, cacheMeta)
+	};
+};
+//#endregion
+//#region src/core/LimitedCacheObject.ts
+const proxyHandler = {
+	get: (cacheMeta, cacheKey) => {
+		if (cacheKey === "hasOwnProperty") return Object.prototype.hasOwnProperty;
+		return lowLevelGetOne(cacheMeta, cacheKey);
+	},
+	getOwnPropertyDescriptor: (cacheMeta, cacheKey) => {
+		const hasResult = lowLevelHas(cacheMeta, cacheKey);
+		const getResult = lowLevelGetOne(cacheMeta, cacheKey);
+		if (hasResult) return {
+			configurable: true,
+			enumerable: hasResult,
+			value: getResult,
+			writable: true
+		};
+	},
+	has: lowLevelHas,
+	set: (cacheMeta, cacheKey, item) => {
+		lowLevelSet(cacheMeta, cacheKey, item);
+		return item;
+	},
+	deleteProperty: (cacheMeta, cacheKey) => {
+		lowLevelRemove(cacheMeta, cacheKey);
+		return true;
+	},
+	ownKeys: (cacheMeta) => Object.keys(lowLevelGetAll(cacheMeta))
+};
+/**
+* TypeScript's Proxy type models the runtime target, but LimitedCacheObject intentionally returns
+* a facade with a different surface from the internal cache metadata target.
+*/
+const internal_createLimitedCacheObjectProxy = (cacheMeta) => {
+	return new Proxy(cacheMeta, proxyHandler);
+};
+/**
+* So that we can retrieve the cacheMeta for a LimitedCacheObject, without polluting its properties, each proxy
+* is associated back to its internal cacheMeta here.
+*/
+const cacheMetasForProxies = /* @__PURE__ */ new WeakMap();
+const LimitedCacheObject = (options) => {
+	const cacheMeta = lowLevelInit(options);
+	const limitedCacheObject = internal_createLimitedCacheObjectProxy(cacheMeta);
+	cacheMetasForProxies.set(limitedCacheObject, cacheMeta);
+	return limitedCacheObject;
+};
+const getCacheMetaFromObject = (instance) => {
+	return cacheMetasForProxies.get(instance);
+};
+//#endregion
+//#region src/core/limitedCacheUtil.ts
+const limitedCacheUtil = {
+	init: lowLevelInit,
+	get: lowLevelGetOne,
+	getAll: lowLevelGetAll,
+	has: lowLevelHas,
+	set: lowLevelSet,
+	remove: lowLevelRemove,
+	reset: lowLevelReset,
+	doMaintenance: lowLevelDoMaintenance,
+	setOptions: lowLevelSetOptions
+};
+//#endregion
+export { CURRENT_META_VERSION, LimitedCache, LimitedCacheObject, MAXIMUM_CACHE_TIME, defaultOptions, getCacheMetaFromObject, isCacheMeta, limitedCacheUtil, lowLevelDoMaintenance, lowLevelGetAll, lowLevelGetOne, lowLevelHas, lowLevelInit, lowLevelRemove, lowLevelReset, lowLevelSet, lowLevelSetOptions, upgradeCacheMeta };
+
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/core/defaultOptions.ts","../../src/core/lowLevelFunctions.ts","../../src/core/LimitedCache.ts","../../src/core/LimitedCacheObject.ts","../../src/core/limitedCacheUtil.ts"],"sourcesContent":["import type { LimitedCacheOptionsReadonly } from '../types.js';\n\nconst CURRENT_META_VERSION = 2 as const;\n// Default = 1 year\nconst MAXIMUM_CACHE_TIME: number = 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, defaultOptions, MAXIMUM_CACHE_TIME };\n","import type {\n  DefaultItemType,\n  LimitedCacheMeta,\n  LimitedCacheOptions,\n  LimitedCacheOptionsFull,\n  LimitedCacheOptionsReadonly,\n} from '../types.js';\nimport { CURRENT_META_VERSION, defaultOptions, MAXIMUM_CACHE_TIME } from './defaultOptions.js';\n\n/* Initialization and options */\n\nconst positiveNumberOrZero = (value: number): number => Math.max(value, 0) || 0;\n\nconst normalizeOptions = (cacheMetaOptions: LimitedCacheOptionsFull): LimitedCacheOptionsFull => {\n  Object.assign(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: unknown): cacheMeta is LimitedCacheMeta => {\n  // @ts-expect-error Duck-typing the unknown value\n  return !!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    // biome-ignore lint/suspicious/noConsole: Intentional warning\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(Object.assign(cacheMeta.options, options));\n};\n\nconst lowLevelInit = <ItemType = DefaultItemType>(\n  optionsOrCacheMeta?: LimitedCacheOptions | LimitedCacheMeta<ItemType>,\n): LimitedCacheMeta<ItemType> => {\n  if (isCacheMeta(optionsOrCacheMeta)) {\n    const existingCacheMeta = optionsOrCacheMeta;\n    upgradeCacheMeta(existingCacheMeta);\n    return existingCacheMeta;\n  }\n  // Else: it's options\n  const fullOptions = normalizeOptions({\n    ...defaultOptions,\n    ...optionsOrCacheMeta,\n  });\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 = Date.now();\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      // This manual assertion is required because TypeScript doesn't know that the initial value is of the same type as the accumulator.\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n      {} as (typeof cacheMeta)['cache'],\n      [] as (typeof cacheMeta)['keyList'],\n      Object.create(null) as (typeof cacheMeta)['keyInfo'],\n    ],\n  );\n\n  return Object.assign(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] as string;\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] as string;\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] as string);\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] as string;\n      const 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] as string;\n    const [oldestItemSetTime, oldestItemExpireTime] = keyInfo[oldestItemKey] as [number, number];\n\n    if (now - oldestItemSetTime < warnIfItemPurgedBeforeTime) {\n      // biome-ignore lint/suspicious/noConsole: Dev-only code\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          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\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  // biome-ignore lint/suspicious/noPrototypeBuiltins: Keeping the legacy hasOwnProperty to avoid a breaking change\n  if (Object.prototype.hasOwnProperty.call(cache, cacheKey) && cache[cacheKey] !== undefined) {\n    if (!_cacheKeyHasExpired(cacheMeta, cacheKey, Date.now())) {\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 = Date.now();\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] as string, 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 Object.assign(cacheMeta, {\n    cache: {},\n    keyList: [],\n    keyInfo: Object.create(null) as Record<string, ItemType>,\n    opsLeft: cacheMeta.options.opLimit,\n  });\n};\n\nexport {\n  isCacheMeta,\n  lowLevelDoMaintenance,\n  lowLevelGetAll,\n  lowLevelGetOne,\n  lowLevelHas,\n  lowLevelInit,\n  lowLevelRemove,\n  lowLevelReset,\n  lowLevelSet,\n  lowLevelSetOptions,\n  upgradeCacheMeta,\n};\n","import type {\n  DefaultItemType,\n  LimitedCacheInstance,\n  LimitedCacheMeta,\n  LimitedCacheOptions,\n  LimitedCacheOptionsReadonly,\n} from '../types.js';\nimport {\n  lowLevelDoMaintenance,\n  lowLevelGetAll,\n  lowLevelGetOne,\n  lowLevelHas,\n  lowLevelInit,\n  lowLevelRemove,\n  lowLevelReset,\n  lowLevelSet,\n  lowLevelSetOptions,\n} from './lowLevelFunctions.js';\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, OtherArgs extends unknown[], ReturnValue>(\n  fn: (cacheMeta: LimitedCacheMeta<ItemType>, ...otherArgs: OtherArgs) => ReturnValue,\n  cacheMeta: LimitedCacheMeta<ItemType>,\n): ((...otherArgs: OtherArgs) => ReturnValue) => 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(lowLevelGetOne, cacheMeta),\n    getAll: bindFunctionToCacheMeta(lowLevelGetAll, cacheMeta),\n    has: bindFunctionToCacheMeta(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(lowLevelReset, cacheMeta),\n    getCacheMeta: (): LimitedCacheMeta<ItemType> => cacheMeta,\n    getOptions: (): LimitedCacheOptionsReadonly => cacheMeta.options,\n    setOptions: bindFunctionToCacheMeta(lowLevelSetOptions, cacheMeta),\n    doMaintenance: bindFunctionToCacheMeta(lowLevelDoMaintenance, cacheMeta),\n  };\n};\n\nexport { LimitedCache };\n","import type {\n  DefaultItemType,\n  LimitedCacheMeta,\n  LimitedCacheObjectInstance,\n  LimitedCacheOptions,\n} from '../types.js';\nimport {\n  lowLevelGetAll,\n  lowLevelGetOne,\n  lowLevelHas,\n  lowLevelInit,\n  lowLevelRemove,\n  lowLevelSet,\n} from './lowLevelFunctions.js';\n\nconst proxyHandler: ProxyHandler<LimitedCacheMeta> = {\n  get: (cacheMeta: LimitedCacheMeta, cacheKey: string) => {\n    if (cacheKey === 'hasOwnProperty') {\n      return Object.prototype.hasOwnProperty;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return lowLevelGetOne(cacheMeta, cacheKey);\n  },\n  getOwnPropertyDescriptor: (cacheMeta: LimitedCacheMeta, cacheKey: string) => {\n    const hasResult = lowLevelHas(cacheMeta, cacheKey);\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n    const getResult = lowLevelGetOne(cacheMeta, cacheKey);\n\n    if (hasResult) {\n      return {\n        configurable: true,\n        enumerable: hasResult,\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n        value: getResult,\n        writable: true,\n      };\n    }\n    return;\n  },\n  has: lowLevelHas,\n  set: <T>(cacheMeta: LimitedCacheMeta, cacheKey: string, item: T): T => {\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 * TypeScript's Proxy type models the runtime target, but LimitedCacheObject intentionally returns\n * a facade with a different surface from the internal cache metadata target.\n */\nconst internal_createLimitedCacheObjectProxy = <ItemType = DefaultItemType>(\n  cacheMeta: LimitedCacheMeta<ItemType>,\n): LimitedCacheObjectInstance<ItemType> => {\n  return new Proxy(cacheMeta, proxyHandler) as unknown as LimitedCacheObjectInstance<ItemType>;\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<ItemType>(options);\n  const limitedCacheObject = internal_createLimitedCacheObjectProxy(cacheMeta);\n\n  cacheMetasForProxies.set(limitedCacheObject, cacheMeta);\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n  return limitedCacheObject;\n};\n\nconst getCacheMetaFromObject = (instance: LimitedCacheObjectInstance): LimitedCacheMeta => {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n  return cacheMetasForProxies.get(instance);\n};\n\nexport { getCacheMetaFromObject, LimitedCacheObject };\n","import {\n  lowLevelDoMaintenance,\n  lowLevelGetAll,\n  lowLevelGetOne,\n  lowLevelHas,\n  lowLevelInit,\n  lowLevelRemove,\n  lowLevelReset,\n  lowLevelSet,\n  lowLevelSetOptions,\n} from './lowLevelFunctions.js';\n\ntype LimitedCacheUtil = {\n  init: typeof lowLevelInit;\n  get: typeof lowLevelGetOne;\n  getAll: typeof lowLevelGetAll;\n  has: typeof lowLevelHas;\n  set: typeof lowLevelSet;\n  remove: typeof lowLevelRemove;\n  reset: typeof lowLevelReset;\n  doMaintenance: typeof lowLevelDoMaintenance;\n  setOptions: typeof lowLevelSetOptions;\n};\n\nconst limitedCacheUtil: 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"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "limited-cache",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "description": "A minimal JS cache: like using an object, except it won't grow forever",
   "keywords": [
     "limited cache",
@@ -23,7 +23,7 @@
   },
   "author": {
     "name": "Steven Pautz",
-    "url": "https://github.com/spautz"
+    "url": "https://stevenpautz.com"
   },
   "publishConfig": {
     "access": "public",
@@ -33,7 +33,6 @@
   "files": [
     "dist/",
     "docs/",
-    "legacy-types/",
     "src/",
     "LICENSE",
     "*.md"
@@ -42,84 +41,68 @@
   "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "types": "./dist/index.d.ts"
+      "local-dev": "./src/index.ts",
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
     },
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "jsnext:main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
   "sideEffects": false,
   "dependencies": {},
   "devDependencies": {
-    "@types/node": "20.1.1"
+    "@arethetypeswrong/cli": "0.18.3",
+    "@size-limit/esbuild": "12.1.0",
+    "@size-limit/esbuild-why": "12.1.0",
+    "@size-limit/file": "12.1.0",
+    "publint": "0.3.21",
+    "size-limit": "12.1.0",
+    "tsdown": "0.22.3"
   },
   "peerDependencies": {},
   "size-limit": [
     {
-      "path": "dist/index.js",
+      "path": "./dist/esm/index.js",
       "import": "{}",
       "limit": "20 B"
     },
     {
-      "path": "dist/index.js",
-      "limit": "2 kB"
+      "path": "./dist/esm/index.js",
+      "import": "{ LimitedCache }",
+      "limit": "1.2 kb"
     }
   ],
-  "typesVersions": {
-    "<4.0": {
-      "*": [
-        "legacy-types/ts3.5/index.d.ts"
-      ]
-    },
-    "<4.5": {
-      "*": [
-        "legacy-types/ts4.0/index.d.ts"
-      ]
-    },
-    "<4.7": {
-      "*": [
-        "legacy-types/ts4.5/index.d.ts"
-      ]
-    },
-    "*": {
-      "*": [
-        "dist/index.d.ts"
-      ]
-    }
-  },
   "scripts": {
     "____ HOOKS _________________________________________________________": "",
-    "____ INTEGRATION ___________________________________________________": "",
-    "clean": "pnpm run build:clean && pnpm run test:clean && rimraf --glob ./node_modules/.cache *.log",
-    "all": "pnpm run format                 && pnpm run typecheck && pnpm run lint:fix && pnpm run test:coverage && pnpm run build",
-    "all:readonly": "pnpm run format:verify && pnpm run typecheck && pnpm run lint     && pnpm run test:quick",
-    "all:quick": "pnpm run format           && pnpm run typecheck && pnpm run lint:fix",
-    "all:ci": "pnpm run format:verify       && pnpm run typecheck && pnpm run lint     && pnpm run test:ci && pnpm run build",
-    "____ INDIVIDUAL COMMANDS ___________________________________________": "",
-    "build": "pnpm run build:main && pnpm run sizecheck && pnpm run build:legacytypes",
-    "build:clean": "rimraf ./dist ./legacy-types",
-    "build:main": "pnpm run build:clean && tsup src/index.ts --format cjs && tsc -p ./tsconfig.build.json",
-    "build:legacytypes": "pnpm run build:legacytypes:3.5 && pnpm run build:legacytypes:4.0 && pnpm run build:legacytypes:4.5",
-    "build:legacytypes:3.5": "downlevel-dts ./dist ./legacy-types/ts3.5 --to=3.5",
-    "build:legacytypes:4.0": "downlevel-dts ./dist ./legacy-types/ts4.0 --to=4.0",
-    "build:legacytypes:4.5": "downlevel-dts ./dist ./legacy-types/ts4.5 --to=4.5",
-    "build:watch": "pnpm run build:clean && tsup src/index.ts --format esm,cjs --dts --watch",
-    "format": "prettier --write .",
-    "format:verify": "prettier --list-different .",
-    "lint": "eslint . --max-warnings 0",
-    "lint:fix": "eslint . --max-warnings 0 --fix",
-    "sizecheck": "size-limit",
-    "test": "pnpm run test:coverage",
+    "____ STANDARD PACKAGE TASKS ________________________________________": "",
+    "all": "turbo run pipeline-all",
+    "all:ci": "turbo run pipeline-ci --ui=stream",
+    "build": "pnpm run build:clean && pnpm run build:lib && pnpm run build:verify",
+    "clean": "pnpm run \"/^.*:clean$/\" && rimraf --glob ./node_modules/.cache ./.turbo ./*.log",
+    "dev": "pnpm run build:lib:watch",
+    "lint": "biome check --write .",
+    "lint:verify": "biome check .",
+    "publish:yalc": "pnpm run prepack && yalc publish --no-scripts --sig --push --replace",
     "test:clean": "rimraf ./coverage",
-    "test:ci": "pnpm run test:clean            && vitest run --coverage",
-    "test:coverage": "pnpm run test:clean      && vitest run --coverage",
-    "test:quick": "pnpm run test:clean         && vitest run --coverage=false",
-    "test:watch": "pnpm run test:clean         && vitest watch --coverage=false",
-    "test:watchcoverage": "pnpm run test:clean && vitest watch --coverage",
-    "typecheck": "tsc -p ./tsconfig.json --noEmit"
+    "test": "pnpm run test:clean       && vitest run --coverage",
+    "test:ci": "pnpm run test:clean    && vitest run --coverage --bail 1",
+    "test:ui": "pnpm run test:clean    && vitest --ui",
+    "test:watch": "pnpm run test:clean && vitest watch --coverage",
+    "typecheck": "tsgo -p ./tsconfig.json --noEmit",
+    "____ BUILD & VALIDATION TASKS ______________________________________": "",
+    "build:clean": "rimraf --glob ./dist ./*.tgz",
+    "build:lib": "tsdown --config ./tsdown.config.ts",
+    "build:lib:watch": "tsdown --config ./tsdown.config.ts --watch",
+    "build:verify": "publint --strict && size-limit",
+    "build:verifypack": "node --experimental-strip-types ../../scripts/verify-packed-tarballs.ts",
+    "size-check": "size-limit --why"
   }
 }

package/src/__tests__/LimitedCache.test.ts

@@ -1,7 +1,7 @@
-import { describe, beforeEach, expect, it } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 import { defaultOptions } from '../core/defaultOptions.js';
 import { LimitedCache } from '../core/LimitedCache.js';
-import { LimitedCacheInstance } from '../types.js';
+import type { LimitedCacheInstance } from '../types.js';
 
 describe('LimitedCache', () => {
   it('initializes without options', () => {

package/src/__tests__/LimitedCacheObject.test.ts

@@ -1,7 +1,10 @@
-import { describe, beforeEach, expect, it } from 'vitest';
+// biome-ignore-all lint/performance/noDelete: Delete is explicitly used to unset items for these tests
+// biome-ignore-all lint/suspicious/noAssignInExpressions: Assignment expressions are explicitly tested
+
+import { beforeEach, describe, expect, it } from 'vitest';
 import { defaultOptions } from '../core/defaultOptions.js';
-import { LimitedCacheObject, getCacheMetaFromObject } from '../core/LimitedCacheObject.js';
-import { LimitedCacheObjectInstance } from '../types.js';
+import { getCacheMetaFromObject, LimitedCacheObject } from '../core/LimitedCacheObject.js';
+import type { LimitedCacheObjectInstance } from '../types.js';
 
 describe('LimitedCacheObject', () => {
   it('initializes without options', () => {
@@ -29,13 +32,13 @@ describe('LimitedCacheObject', () => {
     });
 
     it('has: when missing, via prototype hasOwnProperty', () => {
-      const result = Object.prototype.hasOwnProperty.call(myCache, 'asdf');
+      const result = Object.hasOwn(myCache, 'asdf');
       expect(result).toEqual(false);
     });
 
     it('has: when missing, via local hasOwnProperty', () => {
       // eslint-disable-next-line no-prototype-builtins
-      const result = myCache.hasOwnProperty('asdf');
+      const result = Object.hasOwn(myCache, 'asdf');
       expect(result).toEqual(false);
     });
 
@@ -45,71 +48,71 @@ describe('LimitedCacheObject', () => {
     });
 
     it('has: when present, via prototype hasOwnProperty', () => {
-      myCache.abc = 123;
+      myCache['abc'] = 123;
 
-      const result = Object.prototype.hasOwnProperty.call(myCache, 'abc');
+      const result = Object.hasOwn(myCache, 'abc');
       expect(result).toEqual(true);
     });
 
     it('has: when present, via local hasOwnProperty', () => {
-      myCache.abc = 123;
+      myCache['abc'] = 123;
 
       // eslint-disable-next-line no-prototype-builtins
-      const result = myCache.hasOwnProperty('abc');
+      const result = Object.hasOwn(myCache, 'abc');
       expect(result).toEqual(true);
     });
 
     it('has: when present, via "in"', () => {
-      myCache.abc = 123;
+      myCache['abc'] = 123;
 
       const result = 'abc' in myCache;
       expect(result).toEqual(true);
     });
 
     it('get: when missing', () => {
-      const result = myCache.asdf;
+      const result = myCache['asdf'];
       expect(result).toBeUndefined();
     });
 
     it('get: when present', () => {
-      myCache.abc = 123;
+      myCache['abc'] = 123;
 
-      const result = myCache.abc;
+      const result = myCache['abc'];
       expect(result).toEqual(123);
     });
 
     it('set: when new', () => {
-      const result = (myCache.abc = 123);
+      const result = (myCache['abc'] = 123);
       expect(result).toEqual(123);
     });
 
     it('set: when already present', () => {
-      myCache.abc = 123;
+      myCache['abc'] = 123;
 
-      const result = (myCache.abc = 456);
+      const result = (myCache['abc'] = 456);
       expect(result).toEqual(456);
     });
 
     it('delete and return value', () => {
-      myCache.abc = 123;
+      myCache['abc'] = 123;
 
-      const result = delete myCache.abc;
+      const result = delete myCache['abc'];
       expect(result).toEqual(true);
     });
 
     it('delete, then check', () => {
-      myCache.abc = 123;
-      delete myCache.abc;
+      myCache['abc'] = 123;
+      delete myCache['abc'];
 
-      const result = Object.prototype.hasOwnProperty.call(myCache, 'abc');
+      const result = Object.hasOwn(myCache, 'abc');
       expect(result).toEqual(false);
     });
 
     it('delete, then get', () => {
-      myCache.abc = 123;
-      delete myCache.abc;
+      myCache['abc'] = 123;
+      delete myCache['abc'];
 
-      const result = myCache.abc;
+      const result = myCache['abc'];
       expect(result).toEqual(undefined);
     });
 
@@ -119,15 +122,15 @@ describe('LimitedCacheObject', () => {
     });
 
     it('keys: when populated', () => {
-      myCache.abc = 123;
+      myCache['abc'] = 123;
 
       const result = Object.keys(myCache);
       expect(result).toEqual(['abc']);
     });
 
     it('keys: when all are removed', () => {
-      myCache.abc = 123;
-      delete myCache.abc;
+      myCache['abc'] = 123;
+      delete myCache['abc'];
 
       const result = Object.keys(myCache);
       expect(result).toEqual([]);