@ls-stack/utils 3.41.0 → 3.43.0

package/dist/cache.cjs

@@ -23,7 +23,8 @@ __export(cache_exports, {
   SkipCaching: () => SkipCaching,
   WithExpiration: () => WithExpiration,
   cachedGetter: () => cachedGetter,
-  createCache: () => createCache
+  createCache: () => createCache,
+  fastCache: () => fastCache
 });
 module.exports = __toCommonJS(cache_exports);
 
@@ -258,10 +259,31 @@ function createCache({
     " cache": { map: cache }
   };
 }
+function fastCache({ maxCacheSize = 1e3 } = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  function trimCache() {
+    const cacheSize = cache.size;
+    if (cacheSize > maxCacheSize) {
+      const keys = Array.from(cache.keys());
+      for (let i = 0; i < cacheSize - maxCacheSize; i++) {
+        cache.delete(keys[i]);
+      }
+    }
+  }
+  function getOrInsert(cacheKey, val) {
+    if (!cache.has(cacheKey)) {
+      cache.set(cacheKey, val());
+      trimCache();
+    }
+    return cache.get(cacheKey);
+  }
+  return { getOrInsert, clear: () => cache.clear() };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SkipCaching,
   WithExpiration,
   cachedGetter,
-  createCache
+  createCache,
+  fastCache
 });

package/dist/cache.d.cts

@@ -74,5 +74,12 @@ type Cache<T> = {
     };
 };
 declare function createCache<T>({ maxCacheSize, maxItemAge, expirationThrottle, }?: Options): Cache<T>;
+type FastCacheOptions = {
+    maxCacheSize?: number;
+};
+declare function fastCache<T>({ maxCacheSize }?: FastCacheOptions): {
+    getOrInsert: (cacheKey: string, val: () => T) => T;
+    clear: () => void;
+};
 
-export { type Cache, SkipCaching, WithExpiration, cachedGetter, createCache };
+export { type Cache, SkipCaching, WithExpiration, cachedGetter, createCache, fastCache };

package/dist/cache.d.ts

@@ -74,5 +74,12 @@ type Cache<T> = {
     };
 };
 declare function createCache<T>({ maxCacheSize, maxItemAge, expirationThrottle, }?: Options): Cache<T>;
+type FastCacheOptions = {
+    maxCacheSize?: number;
+};
+declare function fastCache<T>({ maxCacheSize }?: FastCacheOptions): {
+    getOrInsert: (cacheKey: string, val: () => T) => T;
+    clear: () => void;
+};
 
-export { type Cache, SkipCaching, WithExpiration, cachedGetter, createCache };
+export { type Cache, SkipCaching, WithExpiration, cachedGetter, createCache, fastCache };

package/dist/cache.js

@@ -1,217 +1,19 @@
 import {
-  durationObjToMs
-} from "./chunk-5MNYPLZI.js";
+  SkipCaching,
+  WithExpiration,
+  cachedGetter,
+  createCache,
+  fastCache
+} from "./chunk-OIAGLRII.js";
+import "./chunk-5MNYPLZI.js";
 import "./chunk-HTCYUMDR.js";
 import "./chunk-II4R3VVX.js";
-import {
-  isPromise
-} from "./chunk-C2SVCIWE.js";
+import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
-
-// src/cache.ts
-function cachedGetter(getter) {
-  return {
-    get value() {
-      const value = getter();
-      Object.defineProperty(this, "value", { value });
-      return value;
-    }
-  };
-}
-var SkipCaching = class {
-  value;
-  constructor(value) {
-    this.value = value;
-  }
-};
-var WithExpiration = class {
-  value;
-  expiration;
-  /**
-   * @param value - The value to store in the cache.
-   * @param expiration - The expiration time of the value in seconds or a
-   *   duration object.
-   */
-  constructor(value, expiration) {
-    this.value = value;
-    this.expiration = durationObjToMs(expiration);
-  }
-};
-function createCache({
-  maxCacheSize = 1e3,
-  maxItemAge,
-  expirationThrottle = 1e4
-} = {}) {
-  const cache = /* @__PURE__ */ new Map();
-  let lastExpirationCheck = 0;
-  const defaultMaxItemAgeMs = maxItemAge && durationObjToMs(maxItemAge);
-  function cleanExpiredItems() {
-    const now = Date.now();
-    if (!defaultMaxItemAgeMs || now - lastExpirationCheck < expirationThrottle)
-      return;
-    lastExpirationCheck = now;
-    for (const [key, item] of cache.entries()) {
-      if (isExpired(item, now)) {
-        cache.delete(key);
-      }
-    }
-  }
-  function trimToSize() {
-    const currentSize = cache.size;
-    if (currentSize > maxCacheSize) {
-      const keysToRemove = currentSize - maxCacheSize;
-      const iterator = cache.keys();
-      for (let i = 0; i < keysToRemove; i++) {
-        const { value: key } = iterator.next();
-        if (key) {
-          cache.delete(key);
-        }
-      }
-    }
-  }
-  function isExpired(entry, now) {
-    const maxItemAgeMs = entry.expiration ?? defaultMaxItemAgeMs;
-    return !!maxItemAgeMs && now - entry.timestamp > maxItemAgeMs;
-  }
-  function unwrapValue(value, now) {
-    if (value instanceof WithExpiration) {
-      return {
-        value: value.value,
-        timestamp: now,
-        expiration: value.expiration ? typeof value.expiration === "number" ? value.expiration : now + durationObjToMs(value.expiration) : void 0
-      };
-    }
-    return { value, timestamp: now, expiration: void 0 };
-  }
-  const utils = {
-    skipCaching: (value) => new SkipCaching(value),
-    withExpiration: (value, expiration) => {
-      return new WithExpiration(value, expiration);
-    }
-  };
-  return {
-    getOrInsert(cacheKey, val, options) {
-      const now = Date.now();
-      const entry = cache.get(cacheKey);
-      if (!entry || isExpired(entry, now)) {
-        const value = val(utils);
-        if (value instanceof SkipCaching) {
-          return value.value;
-        }
-        if (options?.skipCachingWhen?.(value)) {
-          return value;
-        }
-        const unwrappedValue = unwrapValue(value, now);
-        cache.set(cacheKey, unwrappedValue);
-        trimToSize();
-        cleanExpiredItems();
-        return unwrappedValue.value;
-      }
-      if (isPromise(entry.value)) {
-        throw new Error(
-          "Cache value is a promise, use getOrInsertAsync instead"
-        );
-      }
-      return entry.value;
-    },
-    async getOrInsertAsync(cacheKey, val, options) {
-      const entry = cache.get(cacheKey);
-      if (entry && isPromise(entry.value)) {
-        return entry.value;
-      }
-      const now = Date.now();
-      if (entry && !isExpired(entry, now)) {
-        return entry.value;
-      }
-      const promise = val(utils).then((result) => {
-        if (result instanceof SkipCaching) {
-          const cacheValue = cache.get(cacheKey);
-          if (cacheValue?.value === promise) {
-            cache.delete(cacheKey);
-          }
-          return result.value;
-        }
-        if (options?.skipCachingWhen?.(result)) {
-          const cacheValue = cache.get(cacheKey);
-          if (cacheValue?.value === promise) {
-            cache.delete(cacheKey);
-          }
-          return result;
-        }
-        const unwrappedValue = unwrapValue(result, Date.now());
-        cache.set(cacheKey, unwrappedValue);
-        return unwrappedValue.value;
-      }).catch((error) => {
-        cache.delete(cacheKey);
-        throw error;
-      });
-      cache.set(cacheKey, {
-        value: promise,
-        timestamp: now,
-        expiration: void 0
-      });
-      trimToSize();
-      cleanExpiredItems();
-      return promise;
-    },
-    clear() {
-      cache.clear();
-    },
-    get(cacheKey) {
-      const entry = cache.get(cacheKey);
-      if (!entry || isExpired(entry, Date.now())) {
-        return void 0;
-      }
-      if (isPromise(entry.value)) {
-        throw new Error("Cache value is a promise, use getAsync instead");
-      }
-      return entry.value;
-    },
-    set(cacheKey, value) {
-      cache.set(cacheKey, unwrapValue(value, Date.now()));
-      trimToSize();
-      cleanExpiredItems();
-    },
-    async getAsync(cacheKey) {
-      const entry = cache.get(cacheKey);
-      if (!entry || isExpired(entry, Date.now())) {
-        return void 0;
-      }
-      return entry.value;
-    },
-    async setAsync(cacheKey, value) {
-      const promise = value(utils).then((result) => {
-        if (result instanceof SkipCaching) {
-          const cacheValue = cache.get(cacheKey);
-          if (cacheValue?.value === promise) {
-            cache.delete(cacheKey);
-          }
-          return result.value;
-        }
-        const unwrappedValue = unwrapValue(result, Date.now());
-        cache.set(cacheKey, unwrappedValue);
-        return unwrappedValue.value;
-      }).catch((error) => {
-        cache.delete(cacheKey);
-        throw error;
-      });
-      cache.set(cacheKey, {
-        value: promise,
-        timestamp: Date.now(),
-        expiration: void 0
-      });
-      trimToSize();
-      cleanExpiredItems();
-      return promise;
-    },
-    cleanExpiredItems,
-    /** @internal */
-    " cache": { map: cache }
-  };
-}
 export {
   SkipCaching,
   WithExpiration,
   cachedGetter,
-  createCache
+  createCache,
+  fastCache
 };

package/dist/{chunk-DTE2QMWE.js → chunk-GMJTLFM6.js}

@@ -5,6 +5,9 @@ function asNonPartial(obj) {
 function typedObjectEntries(obj) {
   return Object.entries(obj);
 }
+function strictTypedObjectEntries(obj) {
+  return Object.entries(obj);
+}
 function typedObjectKeys(obj) {
   return Object.keys(obj);
 }
@@ -33,10 +36,17 @@ function unionsAreTheSame(_diff) {
 function asPartialUndefinedValues(value) {
   return value;
 }
+function isNonEmptyArray(array) {
+  return array.length > 0;
+}
+function objectHasKey(obj, key) {
+  return key in obj;
+}
 
 export {
   asNonPartial,
   typedObjectEntries,
+  strictTypedObjectEntries,
   typedObjectKeys,
   asType,
   narrowStringToUnion,
@@ -44,5 +54,7 @@ export {
   isSubTypeOf,
   isObjKey,
   unionsAreTheSame,
-  asPartialUndefinedValues
+  asPartialUndefinedValues,
+  isNonEmptyArray,
+  objectHasKey
 };

package/dist/chunk-OIAGLRII.js

@@ -0,0 +1,236 @@
+import {
+  durationObjToMs
+} from "./chunk-5MNYPLZI.js";
+import {
+  isPromise
+} from "./chunk-C2SVCIWE.js";
+
+// src/cache.ts
+function cachedGetter(getter) {
+  return {
+    get value() {
+      const value = getter();
+      Object.defineProperty(this, "value", { value });
+      return value;
+    }
+  };
+}
+var SkipCaching = class {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+};
+var WithExpiration = class {
+  value;
+  expiration;
+  /**
+   * @param value - The value to store in the cache.
+   * @param expiration - The expiration time of the value in seconds or a
+   *   duration object.
+   */
+  constructor(value, expiration) {
+    this.value = value;
+    this.expiration = durationObjToMs(expiration);
+  }
+};
+function createCache({
+  maxCacheSize = 1e3,
+  maxItemAge,
+  expirationThrottle = 1e4
+} = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  let lastExpirationCheck = 0;
+  const defaultMaxItemAgeMs = maxItemAge && durationObjToMs(maxItemAge);
+  function cleanExpiredItems() {
+    const now = Date.now();
+    if (!defaultMaxItemAgeMs || now - lastExpirationCheck < expirationThrottle)
+      return;
+    lastExpirationCheck = now;
+    for (const [key, item] of cache.entries()) {
+      if (isExpired(item, now)) {
+        cache.delete(key);
+      }
+    }
+  }
+  function trimToSize() {
+    const currentSize = cache.size;
+    if (currentSize > maxCacheSize) {
+      const keysToRemove = currentSize - maxCacheSize;
+      const iterator = cache.keys();
+      for (let i = 0; i < keysToRemove; i++) {
+        const { value: key } = iterator.next();
+        if (key) {
+          cache.delete(key);
+        }
+      }
+    }
+  }
+  function isExpired(entry, now) {
+    const maxItemAgeMs = entry.expiration ?? defaultMaxItemAgeMs;
+    return !!maxItemAgeMs && now - entry.timestamp > maxItemAgeMs;
+  }
+  function unwrapValue(value, now) {
+    if (value instanceof WithExpiration) {
+      return {
+        value: value.value,
+        timestamp: now,
+        expiration: value.expiration ? typeof value.expiration === "number" ? value.expiration : now + durationObjToMs(value.expiration) : void 0
+      };
+    }
+    return { value, timestamp: now, expiration: void 0 };
+  }
+  const utils = {
+    skipCaching: (value) => new SkipCaching(value),
+    withExpiration: (value, expiration) => {
+      return new WithExpiration(value, expiration);
+    }
+  };
+  return {
+    getOrInsert(cacheKey, val, options) {
+      const now = Date.now();
+      const entry = cache.get(cacheKey);
+      if (!entry || isExpired(entry, now)) {
+        const value = val(utils);
+        if (value instanceof SkipCaching) {
+          return value.value;
+        }
+        if (options?.skipCachingWhen?.(value)) {
+          return value;
+        }
+        const unwrappedValue = unwrapValue(value, now);
+        cache.set(cacheKey, unwrappedValue);
+        trimToSize();
+        cleanExpiredItems();
+        return unwrappedValue.value;
+      }
+      if (isPromise(entry.value)) {
+        throw new Error(
+          "Cache value is a promise, use getOrInsertAsync instead"
+        );
+      }
+      return entry.value;
+    },
+    async getOrInsertAsync(cacheKey, val, options) {
+      const entry = cache.get(cacheKey);
+      if (entry && isPromise(entry.value)) {
+        return entry.value;
+      }
+      const now = Date.now();
+      if (entry && !isExpired(entry, now)) {
+        return entry.value;
+      }
+      const promise = val(utils).then((result) => {
+        if (result instanceof SkipCaching) {
+          const cacheValue = cache.get(cacheKey);
+          if (cacheValue?.value === promise) {
+            cache.delete(cacheKey);
+          }
+          return result.value;
+        }
+        if (options?.skipCachingWhen?.(result)) {
+          const cacheValue = cache.get(cacheKey);
+          if (cacheValue?.value === promise) {
+            cache.delete(cacheKey);
+          }
+          return result;
+        }
+        const unwrappedValue = unwrapValue(result, Date.now());
+        cache.set(cacheKey, unwrappedValue);
+        return unwrappedValue.value;
+      }).catch((error) => {
+        cache.delete(cacheKey);
+        throw error;
+      });
+      cache.set(cacheKey, {
+        value: promise,
+        timestamp: now,
+        expiration: void 0
+      });
+      trimToSize();
+      cleanExpiredItems();
+      return promise;
+    },
+    clear() {
+      cache.clear();
+    },
+    get(cacheKey) {
+      const entry = cache.get(cacheKey);
+      if (!entry || isExpired(entry, Date.now())) {
+        return void 0;
+      }
+      if (isPromise(entry.value)) {
+        throw new Error("Cache value is a promise, use getAsync instead");
+      }
+      return entry.value;
+    },
+    set(cacheKey, value) {
+      cache.set(cacheKey, unwrapValue(value, Date.now()));
+      trimToSize();
+      cleanExpiredItems();
+    },
+    async getAsync(cacheKey) {
+      const entry = cache.get(cacheKey);
+      if (!entry || isExpired(entry, Date.now())) {
+        return void 0;
+      }
+      return entry.value;
+    },
+    async setAsync(cacheKey, value) {
+      const promise = value(utils).then((result) => {
+        if (result instanceof SkipCaching) {
+          const cacheValue = cache.get(cacheKey);
+          if (cacheValue?.value === promise) {
+            cache.delete(cacheKey);
+          }
+          return result.value;
+        }
+        const unwrappedValue = unwrapValue(result, Date.now());
+        cache.set(cacheKey, unwrappedValue);
+        return unwrappedValue.value;
+      }).catch((error) => {
+        cache.delete(cacheKey);
+        throw error;
+      });
+      cache.set(cacheKey, {
+        value: promise,
+        timestamp: Date.now(),
+        expiration: void 0
+      });
+      trimToSize();
+      cleanExpiredItems();
+      return promise;
+    },
+    cleanExpiredItems,
+    /** @internal */
+    " cache": { map: cache }
+  };
+}
+function fastCache({ maxCacheSize = 1e3 } = {}) {
+  const cache = /* @__PURE__ */ new Map();
+  function trimCache() {
+    const cacheSize = cache.size;
+    if (cacheSize > maxCacheSize) {
+      const keys = Array.from(cache.keys());
+      for (let i = 0; i < cacheSize - maxCacheSize; i++) {
+        cache.delete(keys[i]);
+      }
+    }
+  }
+  function getOrInsert(cacheKey, val) {
+    if (!cache.has(cacheKey)) {
+      cache.set(cacheKey, val());
+      trimCache();
+    }
+    return cache.get(cacheKey);
+  }
+  return { getOrInsert, clear: () => cache.clear() };
+}
+
+export {
+  cachedGetter,
+  SkipCaching,
+  WithExpiration,
+  createCache,
+  fastCache
+};

package/dist/{chunk-23KPGKDT.js → chunk-Y45CE75W.js}

@@ -1,6 +1,6 @@
 import {
   typedObjectEntries
-} from "./chunk-DTE2QMWE.js";
+} from "./chunk-GMJTLFM6.js";
 import {
   sortBy
 } from "./chunk-27AL66CH.js";

package/dist/concurrentCalls.js

@@ -1,12 +1,12 @@
+import {
+  safeJsonStringify
+} from "./chunk-VAAMRG4K.js";
 import {
   truncateString
 } from "./chunk-B3KFV2MH.js";
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";
-import {
-  safeJsonStringify
-} from "./chunk-VAAMRG4K.js";
 import {
   truncateArray
 } from "./chunk-27AL66CH.js";