@ls-stack/utils 2.10.0 → 2.12.0

package/dist/cache.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/cache.ts
 var cache_exports = {};
 __export(cache_exports, {
+  RejectValue: () => RejectValue,
   cachedGetter: () => cachedGetter,
   createCache: () => createCache
 });
@@ -43,6 +44,12 @@ function cachedGetter(getter) {
     }
   };
 }
+var RejectValue = class {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+};
 function createCache({
   maxCacheSize = 1e3,
   maxItemAge,
@@ -50,7 +57,7 @@ function createCache({
 } = {}) {
   const cache = /* @__PURE__ */ new Map();
   let lastExpirationCheck = 0;
-  function checkExpiredItems() {
+  function cleanExpiredItems() {
     const now = Date.now();
     if (!maxItemAge || now - lastExpirationCheck < expirationThrottle) return;
     lastExpirationCheck = now;
@@ -77,49 +84,103 @@ function createCache({
   function isExpired(timestamp, now) {
     return maxItemAge !== void 0 && now - timestamp > maxItemAge * 1e3;
   }
-  function getOrInsert(cacheKey, val) {
-    const now = Date.now();
-    const entry = cache.get(cacheKey);
-    if (!entry || isExpired(entry.timestamp, now)) {
-      const value = val();
-      cache.set(cacheKey, { value, timestamp: now });
-      trimToSize();
-      checkExpiredItems();
-      return value;
-    }
-    return entry.value;
-  }
-  async function getOrInsertAsync(cacheKey, val) {
-    const entry = cache.get(cacheKey);
-    if (entry && isPromise(entry.value)) {
+  const utils = {
+    reject: (value) => new RejectValue(value)
+  };
+  return {
+    getOrInsert(cacheKey, val) {
+      const now = Date.now();
+      const entry = cache.get(cacheKey);
+      if (!entry || isExpired(entry.timestamp, now)) {
+        const value = val(utils);
+        if (value instanceof RejectValue) {
+          return value.value;
+        }
+        cache.set(cacheKey, { value, timestamp: now });
+        trimToSize();
+        cleanExpiredItems();
+        return value;
+      }
+      if (isPromise(entry.value)) {
+        throw new Error(
+          "Cache value is a promise, use getOrInsertAsync instead"
+        );
+      }
       return entry.value;
-    }
-    const now = Date.now();
-    if (entry && !isExpired(entry.timestamp, now)) {
+    },
+    async getOrInsertAsync(cacheKey, val) {
+      const entry = cache.get(cacheKey);
+      if (entry && isPromise(entry.value)) {
+        return entry.value;
+      }
+      const now = Date.now();
+      if (entry && !isExpired(entry.timestamp, now)) {
+        return entry.value;
+      }
+      const promise = val(utils).then((result) => {
+        if (result instanceof RejectValue) {
+          const cacheValue = cache.get(cacheKey);
+          if (cacheValue?.value === promise) {
+            cache.delete(cacheKey);
+          }
+          return result.value;
+        }
+        cache.set(cacheKey, { value: result, timestamp: Date.now() });
+        return result;
+      }).catch((error) => {
+        cache.delete(cacheKey);
+        throw error;
+      });
+      cache.set(cacheKey, { value: promise, timestamp: now });
+      trimToSize();
+      cleanExpiredItems();
+      return promise;
+    },
+    clear() {
+      cache.clear();
+    },
+    get(cacheKey) {
+      const entry = cache.get(cacheKey);
+      if (!entry || isExpired(entry.timestamp, Date.now())) {
+        return void 0;
+      }
+      if (isPromise(entry.value)) {
+        throw new Error("Cache value is a promise, use getAsync instead");
+      }
       return entry.value;
-    }
-    const promise = val().then((result) => {
-      cache.set(cacheKey, { value: result, timestamp: Date.now() });
-      return result;
-    }).catch((error) => {
-      cache.delete(cacheKey);
-      throw error;
-    });
-    cache.set(cacheKey, { value: promise, timestamp: now });
-    trimToSize();
-    checkExpiredItems();
-    return promise;
-  }
-  return {
-    getOrInsert,
-    getOrInsertAsync,
-    clear: () => cache.clear(),
+    },
+    set(cacheKey, value) {
+      cache.set(cacheKey, { value, timestamp: Date.now() });
+      trimToSize();
+      cleanExpiredItems();
+    },
+    async getAsync(cacheKey) {
+      const entry = cache.get(cacheKey);
+      if (!entry || isExpired(entry.timestamp, Date.now())) {
+        return void 0;
+      }
+      return await entry.value;
+    },
+    setAsync(cacheKey, value) {
+      const promise = value().then((result) => {
+        cache.set(cacheKey, { value: result, timestamp: Date.now() });
+        return result;
+      }).catch((error) => {
+        cache.delete(cacheKey);
+        throw error;
+      });
+      cache.set(cacheKey, { value: promise, timestamp: Date.now() });
+      trimToSize();
+      cleanExpiredItems();
+    },
+    cleanExpiredItems,
     /** @internal */
-    "~cache": cache
+    " cache": { map: cache }
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  RejectValue,
   cachedGetter,
   createCache
 });

package/dist/cache.d.cts

@@ -13,19 +13,35 @@ type Options = {
     maxItemAge?: number;
     /**
      * The throttle for checking expired items in milliseconds.
-     * @default 10_000
+     * @default
+     * 10_000
      */
     expirationThrottle?: number;
 };
-declare function createCache({ maxCacheSize, maxItemAge, expirationThrottle, }?: Options): {
-    getOrInsert: <T>(cacheKey: string, val: () => T) => T;
-    getOrInsertAsync: <T>(cacheKey: string, val: () => Promise<T>) => Promise<T>;
+declare class RejectValue<T> {
+    value: T;
+    constructor(value: T);
+}
+type Cache<T> = {
+    getOrInsert: (cacheKey: string, val: (utils: {
+        reject: (value: T) => RejectValue<T>;
+    }) => T | RejectValue<T>) => T;
+    getOrInsertAsync: (cacheKey: string, val: (utils: {
+        reject: (value: T) => RejectValue<T>;
+    }) => Promise<T | RejectValue<T>>) => Promise<T>;
     clear: () => void;
-    /** @internal */
-    '~cache': Map<string, {
-        value: unknown;
-        timestamp: number;
-    }>;
+    get: (cacheKey: string) => T | undefined;
+    set: (cacheKey: string, value: T) => void;
+    cleanExpiredItems: () => void;
+    getAsync: (cacheKey: string) => Promise<T | undefined>;
+    setAsync: (cacheKey: string, value: () => Promise<T>) => void;
+    [' cache']: {
+        map: Map<string, {
+            value: T | Promise<T>;
+            timestamp: number;
+        }>;
+    };
 };
+declare function createCache<T>({ maxCacheSize, maxItemAge, expirationThrottle, }?: Options): Cache<T>;
 
-export { cachedGetter, createCache };
+export { type Cache, RejectValue, cachedGetter, createCache };

package/dist/cache.d.ts

@@ -13,19 +13,35 @@ type Options = {
     maxItemAge?: number;
     /**
      * The throttle for checking expired items in milliseconds.
-     * @default 10_000
+     * @default
+     * 10_000
      */
     expirationThrottle?: number;
 };
-declare function createCache({ maxCacheSize, maxItemAge, expirationThrottle, }?: Options): {
-    getOrInsert: <T>(cacheKey: string, val: () => T) => T;
-    getOrInsertAsync: <T>(cacheKey: string, val: () => Promise<T>) => Promise<T>;
+declare class RejectValue<T> {
+    value: T;
+    constructor(value: T);
+}
+type Cache<T> = {
+    getOrInsert: (cacheKey: string, val: (utils: {
+        reject: (value: T) => RejectValue<T>;
+    }) => T | RejectValue<T>) => T;
+    getOrInsertAsync: (cacheKey: string, val: (utils: {
+        reject: (value: T) => RejectValue<T>;
+    }) => Promise<T | RejectValue<T>>) => Promise<T>;
     clear: () => void;
-    /** @internal */
-    '~cache': Map<string, {
-        value: unknown;
-        timestamp: number;
-    }>;
+    get: (cacheKey: string) => T | undefined;
+    set: (cacheKey: string, value: T) => void;
+    cleanExpiredItems: () => void;
+    getAsync: (cacheKey: string) => Promise<T | undefined>;
+    setAsync: (cacheKey: string, value: () => Promise<T>) => void;
+    [' cache']: {
+        map: Map<string, {
+            value: T | Promise<T>;
+            timestamp: number;
+        }>;
+    };
 };
+declare function createCache<T>({ maxCacheSize, maxItemAge, expirationThrottle, }?: Options): Cache<T>;
 
-export { cachedGetter, createCache };
+export { type Cache, RejectValue, cachedGetter, createCache };

package/dist/cache.js

@@ -12,6 +12,12 @@ function cachedGetter(getter) {
     }
   };
 }
+var RejectValue = class {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+};
 function createCache({
   maxCacheSize = 1e3,
   maxItemAge,
@@ -19,7 +25,7 @@ function createCache({
 } = {}) {
   const cache = /* @__PURE__ */ new Map();
   let lastExpirationCheck = 0;
-  function checkExpiredItems() {
+  function cleanExpiredItems() {
     const now = Date.now();
     if (!maxItemAge || now - lastExpirationCheck < expirationThrottle) return;
     lastExpirationCheck = now;
@@ -46,48 +52,102 @@ function createCache({
   function isExpired(timestamp, now) {
     return maxItemAge !== void 0 && now - timestamp > maxItemAge * 1e3;
   }
-  function getOrInsert(cacheKey, val) {
-    const now = Date.now();
-    const entry = cache.get(cacheKey);
-    if (!entry || isExpired(entry.timestamp, now)) {
-      const value = val();
-      cache.set(cacheKey, { value, timestamp: now });
-      trimToSize();
-      checkExpiredItems();
-      return value;
-    }
-    return entry.value;
-  }
-  async function getOrInsertAsync(cacheKey, val) {
-    const entry = cache.get(cacheKey);
-    if (entry && isPromise(entry.value)) {
+  const utils = {
+    reject: (value) => new RejectValue(value)
+  };
+  return {
+    getOrInsert(cacheKey, val) {
+      const now = Date.now();
+      const entry = cache.get(cacheKey);
+      if (!entry || isExpired(entry.timestamp, now)) {
+        const value = val(utils);
+        if (value instanceof RejectValue) {
+          return value.value;
+        }
+        cache.set(cacheKey, { value, timestamp: now });
+        trimToSize();
+        cleanExpiredItems();
+        return value;
+      }
+      if (isPromise(entry.value)) {
+        throw new Error(
+          "Cache value is a promise, use getOrInsertAsync instead"
+        );
+      }
       return entry.value;
-    }
-    const now = Date.now();
-    if (entry && !isExpired(entry.timestamp, now)) {
+    },
+    async getOrInsertAsync(cacheKey, val) {
+      const entry = cache.get(cacheKey);
+      if (entry && isPromise(entry.value)) {
+        return entry.value;
+      }
+      const now = Date.now();
+      if (entry && !isExpired(entry.timestamp, now)) {
+        return entry.value;
+      }
+      const promise = val(utils).then((result) => {
+        if (result instanceof RejectValue) {
+          const cacheValue = cache.get(cacheKey);
+          if (cacheValue?.value === promise) {
+            cache.delete(cacheKey);
+          }
+          return result.value;
+        }
+        cache.set(cacheKey, { value: result, timestamp: Date.now() });
+        return result;
+      }).catch((error) => {
+        cache.delete(cacheKey);
+        throw error;
+      });
+      cache.set(cacheKey, { value: promise, timestamp: now });
+      trimToSize();
+      cleanExpiredItems();
+      return promise;
+    },
+    clear() {
+      cache.clear();
+    },
+    get(cacheKey) {
+      const entry = cache.get(cacheKey);
+      if (!entry || isExpired(entry.timestamp, Date.now())) {
+        return void 0;
+      }
+      if (isPromise(entry.value)) {
+        throw new Error("Cache value is a promise, use getAsync instead");
+      }
       return entry.value;
-    }
-    const promise = val().then((result) => {
-      cache.set(cacheKey, { value: result, timestamp: Date.now() });
-      return result;
-    }).catch((error) => {
-      cache.delete(cacheKey);
-      throw error;
-    });
-    cache.set(cacheKey, { value: promise, timestamp: now });
-    trimToSize();
-    checkExpiredItems();
-    return promise;
-  }
-  return {
-    getOrInsert,
-    getOrInsertAsync,
-    clear: () => cache.clear(),
+    },
+    set(cacheKey, value) {
+      cache.set(cacheKey, { value, timestamp: Date.now() });
+      trimToSize();
+      cleanExpiredItems();
+    },
+    async getAsync(cacheKey) {
+      const entry = cache.get(cacheKey);
+      if (!entry || isExpired(entry.timestamp, Date.now())) {
+        return void 0;
+      }
+      return await entry.value;
+    },
+    setAsync(cacheKey, value) {
+      const promise = value().then((result) => {
+        cache.set(cacheKey, { value: result, timestamp: Date.now() });
+        return result;
+      }).catch((error) => {
+        cache.delete(cacheKey);
+        throw error;
+      });
+      cache.set(cacheKey, { value: promise, timestamp: Date.now() });
+      trimToSize();
+      cleanExpiredItems();
+    },
+    cleanExpiredItems,
     /** @internal */
-    "~cache": cache
+    " cache": { map: cache }
   };
 }
 export {
+  RejectValue,
   cachedGetter,
   createCache
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Typescript utils",
-  "version": "2.10.0",
+  "version": "2.12.0",
   "license": "MIT",
   "files": [
     "dist"