limited-cache 2.2.0 → 2.3.0

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAE3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,YAAY,CAAC"}
+{"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.2.0",
+  "version": "2.3.0",
   "description": "A minimal JS cache: like using an object, except it won't grow forever",
   "keywords": [
     "limited cache",
@@ -18,12 +18,12 @@
   "bugs": "https://github.com/spautz/limited-cache/issues",
   "repository": {
     "type": "git",
-    "url": "https://github.com/spautz/limited-cache.git",
+    "url": "git+https://github.com/spautz/limited-cache.git",
     "directory": "packages/limited-cache"
   },
   "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,6 +41,7 @@
   "type": "module",
   "exports": {
     ".": {
+      "local-dev": "./src/index.ts",
       "import": {
         "types": "./dist/esm/index.d.ts",
         "default": "./dist/esm/index.js"
@@ -51,16 +51,22 @@
         "default": "./dist/cjs/index.cjs"
       }
     },
-    "./internal-raw-src": "./src/index.ts",
     "./package.json": "./package.json"
   },
   "main": "./dist/cjs/index.cjs",
   "module": "./dist/esm/index.js",
-  "jsnext:main": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
   "sideEffects": false,
   "dependencies": {},
-  "devDependencies": {},
+  "devDependencies": {
+    "@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": [
     {
@@ -74,54 +80,29 @@
       "limit": "1.2 kb"
     }
   ],
-  "typesVersions": {
-    "<4.0": {
-      "*": [
-        "./legacy-types/ts3.5/*"
-      ]
-    },
-    "<4.5": {
-      "*": [
-        "./legacy-types/ts4.0/*"
-      ]
-    },
-    "<4.7": {
-      "*": [
-        "./legacy-types/ts4.5/*"
-      ]
-    }
-  },
   "scripts": {
     "____ HOOKS _________________________________________________________": "",
-    "____ INTEGRATION ___________________________________________________": "",
-    "clean": "pnpm run build:clean && pnpm run test:clean && rimraf --glob ./node_modules/.cache *.log",
-    "all": "pnpm run          typecheck && pnpm run lint:fix && pnpm run test:coverage && pnpm run build",
-    "all:readonly": "pnpm run typecheck && pnpm run lint     && pnpm run test:quick",
-    "all:quick": "pnpm run    typecheck && pnpm run lint:fix",
-    "all:ci": "pnpm run       typecheck && pnpm run lint     && pnpm run test:ci && pnpm pack",
-    "____ INDIVIDUAL COMMANDS ___________________________________________": "",
-    "build": "pnpm run build:clean && pnpm run build:cjs && pnpm run build:esm && pnpm run build:verify && pnpm run build:legacytypes",
-    "build:clean": "rimraf --glob ./dist ./legacy-types ./*.tgz",
-    "build:cjs": "tsup src/index.ts --format cjs --dts --outDir=./dist/cjs/ --tsconfig=./tsconfig.build-cjs.json",
-    "build:cjs:watch": "pnpm run build:cjs --watch",
-    "build:esm": "tsc -p tsconfig.build-esm.json",
-    "build:esm:watch": "pnpm run build:esm --watch",
-    "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/dist --to=3.5",
-    "build:legacytypes:4.0": "downlevel-dts ./dist ./legacy-types/ts4.0/dist --to=4.0",
-    "build:legacytypes:4.5": "downlevel-dts ./dist ./legacy-types/ts4.5/dist --to=4.5",
-    "build:verify": "publint --strict && size-limit",
-    "build:verifypack": "ls *.tgz | xargs -I {} attw {} --exclude-entrypoints internal-raw-src",
-    "lint": "eslint . --max-warnings 0",
-    "lint:fix": "eslint . --max-warnings 0 --fix",
-    "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:ui": "pnpm run test:clean            && vitest --ui",
-    "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([]);

package/src/__tests__/lowLevelFunctions.test.ts

@@ -1,17 +1,17 @@
-import { describe, beforeEach, expect, it, vitest } from 'vitest';
+import { beforeEach, describe, expect, it, vitest } from 'vitest';
 import { defaultOptions } from '../core/defaultOptions.js';
 import {
   isCacheMeta,
-  upgradeCacheMeta,
-  lowLevelInit,
-  lowLevelGetOne,
   lowLevelGetAll,
+  lowLevelGetOne,
   lowLevelHas,
-  lowLevelSet,
+  lowLevelInit,
   lowLevelRemove,
   lowLevelReset,
+  lowLevelSet,
+  upgradeCacheMeta,
 } from '../core/lowLevelFunctions.js';
-import { LimitedCacheMeta } from '../types.js';
+import type { LimitedCacheMeta } from '../types.js';
 
 describe('lowLevelFunctions', () => {
   describe('isCacheMeta', () => {
@@ -29,7 +29,6 @@ describe('lowLevelFunctions', () => {
     });
     it('rejects invalid cacheMeta shapes', () => {
       expect(
-        // @ts-expect-error Invalid cacheMeta shape
         isCacheMeta({
           cache: {},
         }),
@@ -57,7 +56,7 @@ describe('lowLevelFunctions', () => {
         upgradeCacheMeta({
           cache: {},
         });
-      }).toThrowError();
+      }).toThrow();
     });
   });
 
@@ -168,6 +167,7 @@ describe('lowLevelFunctions', () => {
     });
 
     it('get a missing key', () => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       const result = lowLevelGetOne(myCacheMeta, 'abc');
       expect(result).toBeUndefined();
     });
@@ -178,6 +178,7 @@ describe('lowLevelFunctions', () => {
       myCacheMeta.keyList = ['abc'];
       myCacheMeta.keyInfo['abc'] = [Date.now(), 0];
 
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       const result = lowLevelGetOne(myCacheMeta, 'abc');
       expect(result).toEqual(123);
     });
@@ -188,6 +189,7 @@ describe('lowLevelFunctions', () => {
       myCacheMeta.keyList = ['abc'];
       myCacheMeta.keyInfo['abc'] = [1, 0];
 
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       const result = lowLevelGetOne(myCacheMeta, 'abc');
       expect(result).toEqual(undefined);
     });

package/src/__tests__/scenarios/keys.test.ts

@@ -1,5 +1,5 @@
-import { describe, beforeEach, expect, it } from 'vitest';
-import { limitedCacheUtil, LimitedCacheMeta } from '../../index.js';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { type LimitedCacheMeta, limitedCacheUtil } from '../../index.js';
 
 describe('key names', () => {
   let myCacheMeta: LimitedCacheMeta;

package/src/__tests__/scenarios/maxCacheSize.test.ts

@@ -1,10 +1,10 @@
-import { describe, beforeEach, expect, it, vitest } from 'vitest';
-import { LimitedCache, LimitedCacheInstance } from '../../index.js';
+import { beforeEach, describe, expect, it, vitest } from 'vitest';
+import { LimitedCache, type LimitedCacheInstance } from '../../index.js';
 
 // To avoid race conditions or timing issues, since some expect() checks can take 10+ ms when busy,
 // we use a long cache timeout even for 'immediate' expiration, and use delays slightly longer than that
 const CACHE_TIMEOUT = 20;
-const timeoutPromise = (): Promise<null> =>
+const timeoutPromise = (): Promise<void> =>
   new Promise((resolve) => setTimeout(resolve, CACHE_TIMEOUT + 2));
 
 describe('maxCacheSize scenarios', () => {
@@ -95,7 +95,7 @@ describe('maxCacheSize scenarios', () => {
     expect(Object.keys(myCache.getAll())).toEqual(['n=6', 'n=7', 'n=8', 'n=9', 'n=10']);
   });
 
-  it('warns if a freshly-added item is pushed out too quickly', async () => {
+  it('warns if a freshly-added item is pushed out too quickly', () => {
     myCache = LimitedCache({
       maxCacheSize: 5,
       maxCacheTime: 1000,
@@ -116,7 +116,10 @@ describe('maxCacheSize scenarios', () => {
     // And we should have seen a warning about the force-removed key
     const consoleWarnCalls = consoleWarnSpy.mock.calls;
     expect(consoleWarnCalls.length).toBe(1);
-    const [warningString, warningObject] = consoleWarnCalls[0];
+    const [warningString, warningObject] = consoleWarnCalls[0] as [
+      string,
+      { key: string; value: string },
+    ];
     expect(warningString).toBe(
       'Purged an item from cache while it was still fresh: you may want to increase maxCacheSize',
     );

package/src/__tests__/scenarios/maxCacheTime.test.ts

@@ -1,10 +1,12 @@
-import { describe, beforeEach, expect, it, vitest } from 'vitest';
-import { LimitedCacheObject, LimitedCacheObjectInstance } from '../../index.js';
+// biome-ignore-all lint/performance/noDelete: Delete is explicitly used to unset items for these tests
+
+import { beforeEach, describe, expect, it, vitest } from 'vitest';
+import { LimitedCacheObject, type LimitedCacheObjectInstance } from '../../index.js';
 
 // To avoid race conditions or timing issues, since some expect() checks can take 10+ ms when busy,
 // we use a long cache timeout even for 'immediate' expiration, and use delays slightly longer than that
 const CACHE_TIMEOUT = 25;
-const timeoutPromise = (): Promise<null> =>
+const timeoutPromise = (): Promise<void> =>
   new Promise((resolve) => setTimeout(resolve, CACHE_TIMEOUT + 2));
 
 describe('maxCacheTime scenarios', () => {
@@ -19,41 +21,39 @@ describe('maxCacheTime scenarios', () => {
   });
 
   it("doesn't have keys for expired items", async () => {
-    myCache.abc = 123;
-    myCache.def = 456;
+    myCache['abc'] = 123;
+    myCache['def'] = 456;
     await timeoutPromise();
-    myCache.ghi = 789;
+    myCache['ghi'] = 789;
 
-    const { hasOwnProperty } = Object.prototype;
-    expect(hasOwnProperty.call(myCache, 'abc')).toEqual(false);
-    expect(hasOwnProperty.call(myCache, 'def')).toEqual(false);
+    expect(Object.hasOwn(myCache, 'abc')).toEqual(false);
+    expect(Object.hasOwn(myCache, 'def')).toEqual(false);
 
     expect(Object.keys(myCache)).toEqual(['ghi']);
   });
 
   it('removes expired items on get', async () => {
-    myCache.abc = 123;
-    myCache.def = 456;
+    myCache['abc'] = 123;
+    myCache['def'] = 456;
     await timeoutPromise();
 
-    expect(myCache.abc).toEqual(undefined);
-    expect(myCache.def).toEqual(undefined);
+    expect(myCache['abc']).toEqual(undefined);
+    expect(myCache['def']).toEqual(undefined);
     expect(Object.keys(myCache)).toEqual([]);
   });
 
   it('removes expired items on set', async () => {
-    myCache.abc = 123;
-    myCache.def = 456;
+    myCache['abc'] = 123;
+    myCache['def'] = 456;
     await timeoutPromise();
-    myCache.ghi = 789;
-
-    const { hasOwnProperty } = Object.prototype;
-    expect(hasOwnProperty.call(myCache, 'abc')).toEqual(false);
-    expect(hasOwnProperty.call(myCache, 'def')).toEqual(false);
-    expect(hasOwnProperty.call(myCache, 'ghi')).toEqual(true);
-    expect(myCache.abc).toEqual(undefined);
-    expect(myCache.def).toEqual(undefined);
-    expect(myCache.ghi).toEqual(789);
+    myCache['ghi'] = 789;
+
+    expect(Object.hasOwn(myCache, 'abc')).toEqual(false);
+    expect(Object.hasOwn(myCache, 'def')).toEqual(false);
+    expect(Object.hasOwn(myCache, 'ghi')).toEqual(true);
+    expect(myCache['abc']).toEqual(undefined);
+    expect(myCache['def']).toEqual(undefined);
+    expect(myCache['ghi']).toEqual(789);
     expect(Object.keys(myCache)).toEqual(['ghi']);
   });
 
@@ -65,24 +65,24 @@ describe('maxCacheTime scenarios', () => {
       warnIfItemPurgedBeforeTime: 0,
     });
 
-    myCache.abc = 123;
+    myCache['abc'] = 123;
     await timeoutPromise();
-    myCache.def = 456;
+    myCache['def'] = 456;
     await timeoutPromise();
-    myCache.ghi = 789;
+    myCache['ghi'] = 789;
     await timeoutPromise();
 
     // Now write over the 'oldest' key to reset its timestamp
-    myCache.abc = 123;
+    myCache['abc'] = 123;
 
     // Now, adding a new value (over maxCacheSize) should remove the actual oldest
-    myCache.newOne = 100;
-    expect(myCache.def).toEqual(undefined);
+    myCache['newOne'] = 100;
+    expect(myCache['def']).toEqual(undefined);
     expect(Object.keys(myCache)).toEqual(['abc', 'ghi', 'newOne']);
 
     // And then the next oldest, after that
-    myCache.newTwo = 200;
-    expect(myCache.ghi).toEqual(undefined);
+    myCache['newTwo'] = 200;
+    expect(myCache['ghi']).toEqual(undefined);
     expect(Object.keys(myCache)).toEqual(['abc', 'newOne', 'newTwo']);
   });
 
@@ -94,36 +94,36 @@ describe('maxCacheTime scenarios', () => {
     });
 
     // This first set will expire after the second set gets added
-    myCache.abc = 123;
-    myCache.def = 456;
-    myCache.ghi = 789;
+    myCache['abc'] = 123;
+    myCache['def'] = 456;
+    myCache['ghi'] = 789;
     await timeoutPromise();
-    myCache.jkl = 321;
-    myCache.mno = 654;
-    myCache.abc = 1000;
+    myCache['jkl'] = 321;
+    myCache['mno'] = 654;
+    myCache['abc'] = 1000;
 
     // At this point nothing has been removed, since reusing 'abc' keeps us within maxCacheSize
-    expect(myCache.abc).toEqual(1000);
-    expect(myCache.def).toEqual(456);
-    expect(myCache.ghi).toEqual(789);
+    expect(myCache['abc']).toEqual(1000);
+    expect(myCache['def']).toEqual(456);
+    expect(myCache['ghi']).toEqual(789);
 
     await timeoutPromise();
 
     // Now, adding a new value (over maxCacheSize) should remove both of the remaining expired values
-    myCache.newOne = 100;
-    expect(myCache.def).toEqual(undefined);
-    expect(myCache.ghi).toEqual(undefined);
+    myCache['newOne'] = 100;
+    expect(myCache['def']).toEqual(undefined);
+    expect(myCache['ghi']).toEqual(undefined);
     expect(Object.keys(myCache)).toEqual(['abc', 'jkl', 'mno', 'newOne']);
 
     // And then the next can go in without having to remove anything
-    myCache.newTwo = 200;
-    expect(myCache.jkl).toEqual(321);
-    expect(myCache.mno).toEqual(654);
-    expect(myCache.abc).toEqual(1000);
+    myCache['newTwo'] = 200;
+    expect(myCache['jkl']).toEqual(321);
+    expect(myCache['mno']).toEqual(654);
+    expect(myCache['abc']).toEqual(1000);
     expect(Object.keys(myCache)).toEqual(['abc', 'jkl', 'mno', 'newOne', 'newTwo']);
   });
 
-  it('removes keys for already-removed items first', async () => {
+  it('removes keys for already-removed items first', () => {
     myCache = LimitedCacheObject({
       maxCacheTime: 0,
       maxCacheSize: 5,
@@ -132,18 +132,18 @@ describe('maxCacheTime scenarios', () => {
     });
 
     // This first set will expire after the second set gets added
-    myCache.abc = 123;
-    myCache.def = 456;
-    myCache.ghi = 789;
-    myCache.jkl = 321;
-    myCache.mno = 654;
-    myCache.abc = 1000;
+    myCache['abc'] = 123;
+    myCache['def'] = 456;
+    myCache['ghi'] = 789;
+    myCache['jkl'] = 321;
+    myCache['mno'] = 654;
+    myCache['abc'] = 1000;
 
-    delete myCache.ghi;
-    delete myCache.jkl;
+    delete myCache['ghi'];
+    delete myCache['jkl'];
 
     // Now, adding a new value (over maxCacheSize) should not remove anything else
-    myCache.newOne = 100;
+    myCache['newOne'] = 100;
 
     expect(Object.keys(myCache)).toEqual(['abc', 'def', 'mno', 'newOne']);
   });