limited-cache 2.2.0 → 2.3.1

package/src/core/lowLevelFunctions.ts

@@ -1,24 +1,24 @@
-import { objectAssign, objectCreate, dateNow, hasOwnProperty } from './builtIns.js';
-import { CURRENT_META_VERSION, MAXIMUM_CACHE_TIME, defaultOptions } from './defaultOptions.js';
-import {
-  LimitedCacheOptions,
-  LimitedCacheOptionsReadonly,
+import type {
+  DefaultItemType,
   LimitedCacheMeta,
+  LimitedCacheOptions,
   LimitedCacheOptionsFull,
-  DefaultItemType,
+  LimitedCacheOptionsReadonly,
 } from '../types.js';
+import { CURRENT_META_VERSION, defaultOptions, MAXIMUM_CACHE_TIME } from './defaultOptions.js';
 
 /* Initialization and options */
 
 const positiveNumberOrZero = (value: number): number => Math.max(value, 0) || 0;
 
 const normalizeOptions = (cacheMetaOptions: LimitedCacheOptionsFull): LimitedCacheOptionsFull => {
-  objectAssign(cacheMetaOptions, {
+  Object.assign(cacheMetaOptions, {
     maxCacheSize: positiveNumberOrZero(cacheMetaOptions.maxCacheSize),
     maxCacheTime: positiveNumberOrZero(cacheMetaOptions.maxCacheTime),
     opLimit: positiveNumberOrZero(cacheMetaOptions.opLimit),
   });
 
+  // @ts-expect-error `process.env.NODE_ENV` left intact and not added to global typings
   if (process.env.NODE_ENV !== 'production') {
     cacheMetaOptions.warnIfItemPurgedBeforeTime = positiveNumberOrZero(
       cacheMetaOptions.warnIfItemPurgedBeforeTime,
@@ -27,8 +27,9 @@ const normalizeOptions = (cacheMetaOptions: LimitedCacheOptionsFull): LimitedCac
   return cacheMetaOptions;
 };
 
-const isCacheMeta = (cacheMeta: LimitedCacheMeta): boolean => {
-  return !!cacheMeta && !!cacheMeta.limitedCacheMetaVersion;
+const isCacheMeta = (cacheMeta: unknown): cacheMeta is LimitedCacheMeta => {
+  // @ts-expect-error Duck-typing the unknown value
+  return !!cacheMeta?.limitedCacheMetaVersion;
 };
 
 const upgradeCacheMeta = (cacheMeta: LimitedCacheMeta): void => {
@@ -38,6 +39,7 @@ const upgradeCacheMeta = (cacheMeta: LimitedCacheMeta): void => {
   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
+    // biome-ignore lint/suspicious/noConsole: Intentional warning
     console.warn('Limited-cache metadata is from an incompatible version (1). It must be reset.');
     cacheMeta.limitedCacheMetaVersion = CURRENT_META_VERSION;
     lowLevelReset(cacheMeta);
@@ -49,19 +51,22 @@ const lowLevelSetOptions = <ItemType = DefaultItemType>(
   options: LimitedCacheOptions,
 ): LimitedCacheOptionsReadonly => {
   upgradeCacheMeta(cacheMeta);
-  return normalizeOptions(objectAssign(cacheMeta.options, options));
+  return normalizeOptions(Object.assign(cacheMeta.options, options));
 };
 
 const lowLevelInit = <ItemType = DefaultItemType>(
   optionsOrCacheMeta?: LimitedCacheOptions | LimitedCacheMeta<ItemType>,
 ): LimitedCacheMeta<ItemType> => {
-  if (isCacheMeta(optionsOrCacheMeta as LimitedCacheMeta<ItemType>)) {
-    const existingCacheMeta = optionsOrCacheMeta as LimitedCacheMeta<ItemType>;
+  if (isCacheMeta(optionsOrCacheMeta)) {
+    const existingCacheMeta = optionsOrCacheMeta;
     upgradeCacheMeta(existingCacheMeta);
     return existingCacheMeta;
   }
   // Else: it's options
-  const fullOptions = normalizeOptions({ ...defaultOptions, ...optionsOrCacheMeta });
+  const fullOptions = normalizeOptions({
+    ...defaultOptions,
+    ...optionsOrCacheMeta,
+  });
 
   // The cacheMeta is created once, and persists per instance
   const newCacheMeta = lowLevelReset({
@@ -101,7 +106,7 @@ const lowLevelDoMaintenance = <ItemType = DefaultItemType>(
 ): LimitedCacheMeta<ItemType> => {
   upgradeCacheMeta(cacheMeta);
   const { cache, keyList, keyInfo } = cacheMeta;
-  const now = dateNow();
+  const now = Date.now();
 
   // Rebuild cache from keyList only, checking timestamps to auto-remove expired
   const [newCache, newKeyList, newKeyInfo] = keyList.reduce(
@@ -115,13 +120,15 @@ const lowLevelDoMaintenance = <ItemType = DefaultItemType>(
       return acc;
     },
     [
+      // This manual assertion is required because TypeScript doesn't know that the initial value is of the same type as the accumulator.
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
       {} as (typeof cacheMeta)['cache'],
       [] as (typeof cacheMeta)['keyList'],
-      objectCreate(null) as (typeof cacheMeta)['keyInfo'],
+      Object.create(null) as (typeof cacheMeta)['keyInfo'],
     ],
   );
 
-  return objectAssign(cacheMeta, {
+  return Object.assign(cacheMeta, {
     cache: newCache,
     keyList: newKeyList,
     keyInfo: newKeyInfo,
@@ -134,7 +141,7 @@ const _removeFromIndex = (cacheMeta: LimitedCacheMeta, startIndex: number, now:
 
   // Always remove the item requested, and also remove any neighbors who have expired
   let nextIndex = startIndex;
-  let nextCacheKey = keyList[startIndex];
+  let nextCacheKey = keyList[startIndex] as string;
   const keyListLength = keyList.length;
   do {
     // Remove the 'next' item
@@ -143,7 +150,7 @@ const _removeFromIndex = (cacheMeta: LimitedCacheMeta, startIndex: number, now:
 
     // Now advance and decide whether to keep going
     nextIndex++;
-    nextCacheKey = keyList[nextIndex];
+    nextCacheKey = keyList[nextIndex] as string;
   } while (nextIndex < keyListLength && _cacheKeyHasExpired(cacheMeta, nextCacheKey, now));
 
   // Remove the index for everything from the startIndex until we stopped
@@ -161,14 +168,14 @@ const _removeItemsToMakeRoom = (cacheMeta: LimitedCacheMeta, now: number): void
   // 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.
   let oldestItemIndex = 0;
-  let oldestExpireTime = _getExpireTime(cacheMeta, keyList[0]);
+  let oldestExpireTime = _getExpireTime(cacheMeta, keyList[0] as string);
 
   if (oldestExpireTime > now) {
     // The head of the list hasn't yet expired: scan for a better candidate to remove
     let indexToCheck = 0;
     const maxIndexToCheck = Math.min(keyList.length, scanLimit);
     while (indexToCheck < maxIndexToCheck) {
-      const cacheKeyForIndex = keyList[indexToCheck];
+      const cacheKeyForIndex = keyList[indexToCheck] as string;
       const expireTimeForIndex = _getExpireTime(cacheMeta, cacheKeyForIndex);
 
       // We only consider it if it's eligible for expiration: otherwise it can't be a better option
@@ -191,19 +198,22 @@ const _removeItemsToMakeRoom = (cacheMeta: LimitedCacheMeta, now: number): void
   // 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 (
+    // @ts-expect-error `process.env.NODE_ENV` left intact and not added to global typings
     process.env.NODE_ENV !== 'production' &&
     warnIfItemPurgedBeforeTime &&
     oldestExpireTime > now
   ) {
-    const oldestItemKey = keyList[oldestItemIndex];
+    const oldestItemKey = keyList[oldestItemIndex] as string;
     const [oldestItemSetTime, oldestItemExpireTime] = keyInfo[oldestItemKey] as [number, number];
 
     if (now - oldestItemSetTime < warnIfItemPurgedBeforeTime) {
+      // biome-ignore lint/suspicious/noConsole: Dev-only code
       console.warn(
         'Purged an item from cache while it was still fresh: you may want to increase maxCacheSize',
         {
           currentTime: now,
           key: oldestItemKey,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           item: cache[oldestItemKey],
           setTime: oldestItemSetTime,
           expireTime: oldestItemExpireTime,
@@ -225,8 +235,9 @@ const lowLevelHas = <ItemType = DefaultItemType>(
 ): boolean => {
   upgradeCacheMeta(cacheMeta);
   const { cache } = cacheMeta;
-  if (hasOwnProperty.call(cache, cacheKey) && cache[cacheKey] !== undefined) {
-    if (!_cacheKeyHasExpired(cacheMeta, cacheKey, dateNow())) {
+  // biome-ignore lint/suspicious/noPrototypeBuiltins: Keeping the legacy hasOwnProperty to avoid a breaking change
+  if (Object.prototype.hasOwnProperty.call(cache, cacheKey) && cache[cacheKey] !== undefined) {
+    if (!_cacheKeyHasExpired(cacheMeta, cacheKey, Date.now())) {
       return true;
     }
     // If it's expired, clear the value so that we can short-circuit future lookups
@@ -269,7 +280,7 @@ const lowLevelSet = <ItemType = DefaultItemType>(
     keyInfo,
   } = cacheMeta;
 
-  const now = dateNow();
+  const now = Date.now();
   const isNew = !keyInfo[cacheKey];
 
   if (cacheMeta.cache[cacheKey] !== item) {
@@ -299,7 +310,7 @@ const lowLevelSet = <ItemType = DefaultItemType>(
     }
   }
 
-  if (_cacheKeyHasExpired(cacheMeta, keyList[0], now)) {
+  if (_cacheKeyHasExpired(cacheMeta, keyList[0] as string, now)) {
     // While we're here, if we need to expire the head of the queue then drop it
     _removeFromIndex(cacheMeta, 0, now);
   }
@@ -331,24 +342,24 @@ const lowLevelReset = <ItemType = DefaultItemType>(
   cacheMeta: LimitedCacheMeta<ItemType>,
 ): LimitedCacheMeta<ItemType> => {
   upgradeCacheMeta(cacheMeta);
-  return objectAssign(cacheMeta, {
+  return Object.assign(cacheMeta, {
     cache: {},
     keyList: [],
-    keyInfo: objectCreate(null),
+    keyInfo: Object.create(null) as Record<string, ItemType>,
     opsLeft: cacheMeta.options.opLimit,
   });
 };
 
 export {
   isCacheMeta,
-  upgradeCacheMeta,
-  lowLevelInit,
-  lowLevelGetOne,
+  lowLevelDoMaintenance,
   lowLevelGetAll,
+  lowLevelGetOne,
   lowLevelHas,
-  lowLevelSet,
+  lowLevelInit,
   lowLevelRemove,
   lowLevelReset,
-  lowLevelDoMaintenance,
+  lowLevelSet,
   lowLevelSetOptions,
+  upgradeCacheMeta,
 };

package/src/types.ts

@@ -1,7 +1,8 @@
 // This makes it easy to ensure that ItemType gets passed to any nested generics:
-// Using `unknown` helps catch errors during development but is a pain for consumers.
-// Using `any` is nicer for consumers, but errors could slip through during development.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+//  * Using `unknown` helps catch errors during development but is a pain for consumers.
+//  * Using `any` is nicer for consumers, but errors could slip through during development.
+// In v3.0.0 the default will change from `any` to `unknown`
+// biome-ignore lint/suspicious/noExplicitAny: Intentionally left as any for better DX
 export type DefaultItemType = any;
 
 export interface LimitedCacheOptionsFull {

package/dist/esm/core/LimitedCache.d.ts

@@ -1,4 +0,0 @@
-import { LimitedCacheOptions, LimitedCacheInstance } from '../types.js';
-declare const LimitedCache: <ItemType = any>(options?: LimitedCacheOptions) => LimitedCacheInstance<ItemType>;
-export { LimitedCache };
-//# sourceMappingURL=LimitedCache.d.ts.map

package/dist/esm/core/LimitedCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LimitedCache.d.ts","sourceRoot":"","sources":["../../../src/core/LimitedCache.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,mBAAmB,EAEnB,oBAAoB,EAGrB,MAAM,aAAa,CAAC;AAUrB,QAAA,MAAM,YAAY,6BACN,mBAAmB,mCAsB9B,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/esm/core/LimitedCache.js

@@ -1,29 +0,0 @@
-import { lowLevelInit, lowLevelGetOne, lowLevelGetAll, lowLevelHas, lowLevelSet, lowLevelRemove, lowLevelReset, lowLevelSetOptions, lowLevelDoMaintenance, } from './lowLevelFunctions.js';
-// Most public functions just call a low-level function directly, passing the cacheMeta.
-// Doing this via a helper function makes the typeChecks easier, and minifies better.
-const bindFunctionToCacheMeta = (
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-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),
-    };
-};
-export { LimitedCache };
-//# sourceMappingURL=LimitedCache.js.map

package/dist/esm/core/LimitedCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LimitedCache.js","sourceRoot":"","sources":["../../../src/core/LimitedCache.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,cAAc,EACd,cAAc,EACd,WAAW,EACX,WAAW,EACX,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAShC,wFAAwF;AACxF,qFAAqF;AACrF,MAAM,uBAAuB,GAAG;AAC9B,8DAA8D;AAC9D,EAAqE,EACrE,SAAqC,EACrC,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;AAE9B,MAAM,YAAY,GAAG,CACnB,OAA6B,EACG,EAAE;IAClC,MAAM,SAAS,GAAG,YAAY,CAAW,OAAO,CAAC,CAAC;IAElD,OAAO;QACL,GAAG,EAAE,uBAAuB,CAAW,cAAc,EAAE,SAAS,CAAC;QACjE,MAAM,EAAE,uBAAuB,CAAW,cAAc,EAAE,SAAS,CAAC;QACpE,GAAG,EAAE,uBAAuB,CAAW,WAAW,EAAE,SAAS,CAAC;QAC9D,GAAG,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAY,EAAE;YAChC,WAAW,CAAC,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;YACvC,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,EAAE,CAAC,QAAQ,EAAQ,EAAE;YACzB,cAAc,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YACpC,OAAO,IAAI,CAAC;QACd,CAAC;QACD,KAAK,EAAE,uBAAuB,CAAW,aAAa,EAAE,SAAS,CAAC;QAClE,YAAY,EAAE,GAA+B,EAAE,CAAC,SAAS;QACzD,UAAU,EAAE,GAAgC,EAAE,CAAC,SAAS,CAAC,OAAO;QAChE,UAAU,EAAE,uBAAuB,CAAW,kBAAkB,EAAE,SAAS,CAAC;QAC5E,aAAa,EAAE,uBAAuB,CAAW,qBAAqB,EAAE,SAAS,CAAC;KACnF,CAAC;AACJ,CAAC,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/esm/core/LimitedCacheObject.d.ts

@@ -1,5 +0,0 @@
-import { LimitedCacheOptions, LimitedCacheObjectInstance, LimitedCacheMeta } from '../types.js';
-declare const LimitedCacheObject: <ItemType = any>(options?: LimitedCacheOptions) => LimitedCacheObjectInstance<ItemType>;
-declare const getCacheMetaFromObject: (instance: LimitedCacheObjectInstance) => LimitedCacheMeta;
-export { LimitedCacheObject, getCacheMetaFromObject };
-//# sourceMappingURL=LimitedCacheObject.d.ts.map

package/dist/esm/core/LimitedCacheObject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LimitedCacheObject.d.ts","sourceRoot":"","sources":["../../../src/core/LimitedCacheObject.ts"],"names":[],"mappings":"AASA,OAAO,EACL,mBAAmB,EACnB,0BAA0B,EAC1B,gBAAgB,EAEjB,MAAM,aAAa,CAAC;AA4CrB,QAAA,MAAM,kBAAkB,6BACZ,mBAAmB,yCAO9B,CAAC;AAEF,QAAA,MAAM,sBAAsB,aAAc,0BAA0B,KAAG,gBAEtE,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/esm/core/LimitedCacheObject.js

@@ -1,52 +0,0 @@
-import { hasOwnProperty } from './builtIns.js';
-import { lowLevelInit, lowLevelGetOne, lowLevelGetAll, lowLevelHas, lowLevelSet, lowLevelRemove, } from './lowLevelFunctions.js';
-// The `any` here doesn't escape out anywhere: it's overridden by the constructor below
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const proxyHandler = {
-    get: (cacheMeta, cacheKey) => {
-        if (cacheKey === 'hasOwnProperty') {
-            return 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,
-            };
-        }
-        return;
-    },
-    has: lowLevelHas,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    set: (cacheMeta, cacheKey, item) => {
-        lowLevelSet(cacheMeta, cacheKey, item);
-        return item;
-    },
-    deleteProperty: (cacheMeta, cacheKey) => {
-        lowLevelRemove(cacheMeta, cacheKey);
-        return true;
-    },
-    ownKeys: (cacheMeta) => 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.
- */
-const cacheMetasForProxies = new WeakMap();
-const LimitedCacheObject = (options) => {
-    const cacheMeta = lowLevelInit(options);
-    const limitedCacheObject = new Proxy(cacheMeta, proxyHandler);
-    cacheMetasForProxies.set(limitedCacheObject, cacheMeta);
-    return limitedCacheObject;
-};
-const getCacheMetaFromObject = (instance) => {
-    return cacheMetasForProxies.get(instance);
-};
-export { LimitedCacheObject, getCacheMetaFromObject };
-//# sourceMappingURL=LimitedCacheObject.js.map

package/dist/esm/core/LimitedCacheObject.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LimitedCacheObject.js","sourceRoot":"","sources":["../../../src/core/LimitedCacheObject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EACL,YAAY,EACZ,cAAc,EACd,cAAc,EACd,WAAW,EACX,WAAW,EACX,cAAc,GACf,MAAM,wBAAwB,CAAC;AAQhC,uFAAuF;AACvF,8DAA8D;AAC9D,MAAM,YAAY,GAAkD;IAClE,GAAG,EAAE,CAAC,SAA2B,EAAE,QAAgB,EAAE,EAAE;QACrD,IAAI,QAAQ,KAAK,gBAAgB,EAAE,CAAC;YAClC,OAAO,cAAc,CAAC;QACxB,CAAC;QACD,OAAO,cAAc,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC7C,CAAC;IACD,wBAAwB,EAAE,CAAC,SAA2B,EAAE,QAAgB,EAAE,EAAE;QAC1E,MAAM,SAAS,GAAG,WAAW,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QACnD,MAAM,SAAS,GAAG,cAAc,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QAEtD,IAAI,SAAS,EAAE,CAAC;YACd,OAAO;gBACL,YAAY,EAAE,IAAI;gBAClB,UAAU,EAAE,SAAS;gBACrB,KAAK,EAAE,SAAS;gBAChB,QAAQ,EAAE,IAAI;aACf,CAAC;QACJ,CAAC;QACD,OAAO;IACT,CAAC;IACD,GAAG,EAAE,WAAW;IAChB,8DAA8D;IAC9D,GAAG,EAAE,CAAC,SAA2B,EAAE,QAAgB,EAAE,IAAS,EAAO,EAAE;QACrE,WAAW,CAAC,SAAS,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;QACvC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,cAAc,EAAE,CAAC,SAA2B,EAAE,QAAgB,EAAQ,EAAE;QACtE,cAAc,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QACpC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,EAAE,CAAC,SAA2B,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;CACjF,CAAC;AAEF;;;GAGG;AACH,MAAM,oBAAoB,GAAG,IAAI,OAAO,EAAE,CAAC;AAE3C,MAAM,kBAAkB,GAAG,CACzB,OAA6B,EACS,EAAE;IACxC,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;IACxC,MAAM,kBAAkB,GAAG,IAAI,KAAK,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;IAE9D,oBAAoB,CAAC,GAAG,CAAC,kBAAkB,EAAE,SAAS,CAAC,CAAC;IACxD,OAAO,kBAAkB,CAAC;AAC5B,CAAC,CAAC;AAEF,MAAM,sBAAsB,GAAG,CAAC,QAAoC,EAAoB,EAAE;IACxF,OAAO,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAC5C,CAAC,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/esm/core/builtIns.d.ts

@@ -1,12 +0,0 @@
-declare const objectCreate: {
-    (o: object | null): any;
-    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
-}, objectAssign: {
-    <T extends {}, U>(target: T, source: U): T & U;
-    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
-    <T_2 extends {}, 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: PropertyKey) => boolean;
-declare const dateNow: () => number;
-export { objectAssign, objectCreate, dateNow, hasOwnProperty };
-//# sourceMappingURL=builtIns.d.ts.map

package/dist/esm/core/builtIns.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtIns.d.ts","sourceRoot":"","sources":["../../../src/core/builtIns.ts"],"names":[],"mappings":"AACA,QAAA,MACU,YAAY;;;GACZ,YAAY;;;;;GACP,cAAc,6BACnB,CAAC;AACX,QAAA,MAAM,OAAO,cAAW,CAAC;AAEzB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/esm/core/builtIns.js

@@ -1,5 +0,0 @@
-// To help minification
-const { create: objectCreate, assign: objectAssign, prototype: { hasOwnProperty }, } = Object;
-const dateNow = Date.now;
-export { objectAssign, objectCreate, dateNow, hasOwnProperty };
-//# sourceMappingURL=builtIns.js.map

package/dist/esm/core/builtIns.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtIns.js","sourceRoot":"","sources":["../../../src/core/builtIns.ts"],"names":[],"mappings":"AAAA,uBAAuB;AACvB,MAAM,EACJ,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,YAAY,EACpB,SAAS,EAAE,EAAE,cAAc,EAAE,GAC9B,GAAG,MAAM,CAAC;AACX,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC;AAEzB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/esm/core/defaultOptions.d.ts

@@ -1,6 +0,0 @@
-import { LimitedCacheOptionsReadonly } from '../types.js';
-declare const CURRENT_META_VERSION = 2;
-declare const MAXIMUM_CACHE_TIME: number;
-declare const defaultOptions: LimitedCacheOptionsReadonly;
-export { CURRENT_META_VERSION, MAXIMUM_CACHE_TIME, defaultOptions };
-//# sourceMappingURL=defaultOptions.d.ts.map

package/dist/esm/core/defaultOptions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultOptions.d.ts","sourceRoot":"","sources":["../../../src/core/defaultOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAE1D,QAAA,MAAM,oBAAoB,IAAI,CAAC;AAC/B,QAAA,MAAM,kBAAkB,QAAqB,CAAC;AAE9C,QAAA,MAAM,cAAc,EAAE,2BASrB,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAC"}

package/dist/esm/core/defaultOptions.js

@@ -1,14 +0,0 @@
-const CURRENT_META_VERSION = 2;
-const MAXIMUM_CACHE_TIME = 365 * 86400 * 1000;
-const defaultOptions = {
-    // Public
-    maxCacheSize: 100,
-    maxCacheTime: 86400 * 1000,
-    // Development-only
-    warnIfItemPurgedBeforeTime: 5000,
-    // Private
-    opLimit: 200,
-    scanLimit: 50,
-};
-export { CURRENT_META_VERSION, MAXIMUM_CACHE_TIME, defaultOptions };
-//# sourceMappingURL=defaultOptions.js.map

package/dist/esm/core/defaultOptions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultOptions.js","sourceRoot":"","sources":["../../../src/core/defaultOptions.ts"],"names":[],"mappings":"AAEA,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAC/B,MAAM,kBAAkB,GAAG,GAAG,GAAG,KAAK,GAAG,IAAI,CAAC;AAE9C,MAAM,cAAc,GAAgC;IAClD,SAAS;IACT,YAAY,EAAE,GAAG;IACjB,YAAY,EAAE,KAAK,GAAG,IAAI;IAC1B,mBAAmB;IACnB,0BAA0B,EAAE,IAAI;IAChC,UAAU;IACV,OAAO,EAAE,GAAG;IACZ,SAAS,EAAE,EAAE;CACd,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAC"}

package/dist/esm/core/limitedCacheUtil.d.ts

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

package/dist/esm/core/limitedCacheUtil.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"limitedCacheUtil.d.ts","sourceRoot":"","sources":["../../../src/core/limitedCacheUtil.ts"],"names":[],"mappings":"AAYA,QAAA,MAAM,gBAAgB;;;;;;;;;;CAUrB,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/esm/core/limitedCacheUtil.js

@@ -1,14 +0,0 @@
-import { lowLevelGetOne, lowLevelGetAll, lowLevelHas, lowLevelInit, lowLevelDoMaintenance, lowLevelRemove, lowLevelReset, lowLevelSet, lowLevelSetOptions, } from './lowLevelFunctions.js';
-const limitedCacheUtil = {
-    init: lowLevelInit,
-    get: lowLevelGetOne,
-    getAll: lowLevelGetAll,
-    has: lowLevelHas,
-    set: lowLevelSet,
-    remove: lowLevelRemove,
-    reset: lowLevelReset,
-    doMaintenance: lowLevelDoMaintenance,
-    setOptions: lowLevelSetOptions,
-};
-export { limitedCacheUtil };
-//# sourceMappingURL=limitedCacheUtil.js.map

package/dist/esm/core/limitedCacheUtil.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"limitedCacheUtil.js","sourceRoot":"","sources":["../../../src/core/limitedCacheUtil.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,cAAc,EACd,WAAW,EACX,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACd,aAAa,EACb,WAAW,EACX,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,gBAAgB,GAAG;IACvB,IAAI,EAAE,YAAY;IAClB,GAAG,EAAE,cAAc;IACnB,MAAM,EAAE,cAAc;IACtB,GAAG,EAAE,WAAW;IAChB,GAAG,EAAE,WAAW;IAChB,MAAM,EAAE,cAAc;IACtB,KAAK,EAAE,aAAa;IACpB,aAAa,EAAE,qBAAqB;IACpC,UAAU,EAAE,kBAAkB;CAC/B,CAAC;AAEF,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/esm/core/lowLevelFunctions.d.ts

@@ -1,14 +0,0 @@
-import { LimitedCacheOptions, LimitedCacheOptionsReadonly, LimitedCacheMeta } from '../types.js';
-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?: LimitedCacheOptions | LimitedCacheMeta<ItemType> | 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, };
-//# sourceMappingURL=lowLevelFunctions.d.ts.map

package/dist/esm/core/lowLevelFunctions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lowLevelFunctions.d.ts","sourceRoot":"","sources":["../../../src/core/lowLevelFunctions.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,mBAAmB,EACnB,2BAA2B,EAC3B,gBAAgB,EAGjB,MAAM,aAAa,CAAC;AAqBrB,QAAA,MAAM,WAAW,cAAe,gBAAgB,KAAG,OAElD,CAAC;AAEF,QAAA,MAAM,gBAAgB,cAAe,gBAAgB,KAAG,IAWvD,CAAC;AAEF,QAAA,MAAM,kBAAkB,mEAEb,mBAAmB,KAC3B,2BAGF,CAAC;AAEF,QAAA,MAAM,YAAY,mIAkBjB,CAAC;AA0BF,QAAA,MAAM,qBAAqB,uFA+B1B,CAAC;AA4FF,QAAA,MAAM,WAAW,oEAEL,MAAM,KACf,OAWF,CAAC;AAEF,QAAA,MAAM,cAAc,oEAER,MAAM,yBAOjB,CAAC;AAEF,QAAA,MAAM,cAAc,qFAQnB,CAAC;AAEF,QAAA,MAAM,WAAW,oEAEL,MAAM,+CA+CjB,CAAC;AAEF,QAAA,MAAM,cAAc,oEAER,MAAM,+BAgBjB,CAAC;AAEF,QAAA,MAAM,aAAa,uFAUlB,CAAC;AAEF,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,YAAY,EACZ,cAAc,EACd,cAAc,EACd,WAAW,EACX,WAAW,EACX,cAAc,EACd,aAAa,EACb,qBAAqB,EACrB,kBAAkB,GACnB,CAAC"}