@ls-stack/utils 3.42.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-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/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";

package/dist/matchPath.cjs

@@ -0,0 +1,148 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/matchPath.ts
+var matchPath_exports = {};
+__export(matchPath_exports, {
+  matchPath: () => matchPath,
+  matchPathWith: () => matchPathWith
+});
+module.exports = __toCommonJS(matchPath_exports);
+
+// src/cache.ts
+function fastCache({ maxCacheSize = 1e3 } = {}) {
+  const cache2 = /* @__PURE__ */ new Map();
+  function trimCache() {
+    const cacheSize = cache2.size;
+    if (cacheSize > maxCacheSize) {
+      const keys = Array.from(cache2.keys());
+      for (let i = 0; i < cacheSize - maxCacheSize; i++) {
+        cache2.delete(keys[i]);
+      }
+    }
+  }
+  function getOrInsert(cacheKey, val) {
+    if (!cache2.has(cacheKey)) {
+      cache2.set(cacheKey, val());
+      trimCache();
+    }
+    return cache2.get(cacheKey);
+  }
+  return { getOrInsert, clear: () => cache2.clear() };
+}
+
+// src/matchPath.ts
+function matchPath(pattern, pathname) {
+  if (typeof pattern === "string") {
+    pattern = { path: pattern, caseSensitive: false, end: true };
+  }
+  const [matcher, compiledParams] = compilePath(
+    pattern.path,
+    pattern.caseSensitive,
+    pattern.end
+  );
+  const match = pathname.match(matcher);
+  if (!match) return null;
+  const matchedPathname = match[0];
+  let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
+  const captureGroups = match.slice(1);
+  const params = compiledParams.reduce(
+    (memo, { paramName, isOptional }, index) => {
+      if (paramName === "*") {
+        const splatValue = captureGroups[index] || "";
+        pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
+      }
+      const value = captureGroups[index];
+      if (isOptional && !value) {
+        memo[paramName] = void 0;
+      } else {
+        memo[paramName] = (value || "").replace(/%2F/g, "/");
+      }
+      return memo;
+    },
+    {}
+  );
+  const glob = params["*"];
+  const globPath = glob && `/${glob}`;
+  return {
+    params,
+    pathname: matchedPathname,
+    pathnameBase,
+    pattern,
+    glob: globPath ? {
+      matchPath: (subPattern) => matchPath(subPattern, globPath),
+      path: globPath
+    } : null
+  };
+}
+function warning(condition, message) {
+  if (process.env.NODE_ENV === "development" && !condition) {
+    console.warn(message);
+  }
+}
+var cache = fastCache({ maxCacheSize: 5e3 });
+function compilePath(path, caseSensitive = false, end = true) {
+  return cache.getOrInsert(
+    `${path}-${caseSensitive ? "s" : "i"}${end ? "e" : ""}`,
+    () => {
+      warning(
+        path === "*" || !path.endsWith("*") || path.endsWith("/*"),
+        `Route path "${path}" will be treated as if it were "${path.replace(/\*$/, "/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${path.replace(/\*$/, "/*")}".`
+      );
+      const params = [];
+      let regexpSource = `^${path.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(
+        /\/:([\w-]+)(\?)?/g,
+        (_, paramName, isOptional) => {
+          params.push({ paramName, isOptional: isOptional != null });
+          return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
+        }
+      )}`;
+      if (path.endsWith("*")) {
+        params.push({ paramName: "*" });
+        regexpSource += path === "*" || path === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$";
+      } else if (end) {
+        regexpSource += "\\/*$";
+      } else if (path !== "" && path !== "/") {
+        regexpSource += "(?:(?=\\/|$))";
+      } else {
+      }
+      const matcher = new RegExp(regexpSource, caseSensitive ? void 0 : "i");
+      return [matcher, params];
+    }
+  );
+}
+function matchPathWith(path) {
+  return {
+    patterns: (patternsToMatch) => {
+      if (!path) return null;
+      for (const [key, pattern] of Object.entries(patternsToMatch)) {
+        const match = matchPath(key, path);
+        if (match) {
+          return pattern(match);
+        }
+      }
+      return null;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  matchPath,
+  matchPathWith
+});