@ls-stack/utils 3.65.0 → 3.66.0

package/dist/chunk-DBOWTYR4.js

@@ -1,49 +0,0 @@
-// src/mathUtils.ts
-function clampMax(value, max) {
-  return value > max ? max : value;
-}
-function clampMin(value, min) {
-  return value < min ? min : value;
-}
-function clampRange(num, v1, v2) {
-  if (v2 > v1) {
-    return clamp(num, v1, v2);
-  }
-  return clamp(num, v2, v1);
-}
-function clamp(num, min, max) {
-  return num > max ? max : num < min ? min : num;
-}
-function fixFloatingPointNumber(value) {
-  return Number(value.toPrecision(15));
-}
-function roundToStep(value, step, offset = 0) {
-  const inv = 1 / step;
-  const snapped = Math.round((value - offset) * inv) / inv + offset;
-  return Number(snapped.toFixed(12));
-}
-function floorToStep(value, step, offset = 0) {
-  const inv = 1 / step;
-  const snapped = Math.floor((value - offset) * inv) / inv + offset;
-  return Number(snapped.toFixed(12));
-}
-function ceilToStep(value, step, offset = 0) {
-  const inv = 1 / step;
-  const snapped = Math.ceil((value - offset) * inv) / inv + offset;
-  return Number(snapped.toFixed(12));
-}
-function round(num, precision) {
-  return Math.round(num * 10 ** precision) / 10 ** precision;
-}
-
-export {
-  clampMax,
-  clampMin,
-  clampRange,
-  clamp,
-  fixFloatingPointNumber,
-  roundToStep,
-  floorToStep,
-  ceilToStep,
-  round
-};

package/dist/chunk-DFXNVEH6.js

@@ -1,14 +0,0 @@
-// src/promiseUtils.ts
-function defer() {
-  let resolve;
-  let reject;
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve;
-    reject = _reject;
-  });
-  return { resolve, reject, promise };
-}
-
-export {
-  defer
-};

package/dist/chunk-DX2524CZ.js

@@ -1,314 +0,0 @@
-import {
-  durationObjToMs
-} from "./chunk-6FBIEPWU.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);
-    }
-  };
-  function refreshEntry(key, now) {
-    const entry = cache.get(key);
-    if (entry && !isExpired(entry, now)) {
-      cache.delete(key);
-      cache.set(key, entry);
-    }
-  }
-  return {
-    /**
-     * Gets a value from the cache or computes and stores it if not present.
-     * This is the primary method for synchronous caching operations.
-     *
-     * @param cacheKey - Unique key to identify the cached value
-     * @param val - Function that computes the value if not cached. Receives
-     *   utility functions for advanced features.
-     * @param options - Optional configuration for this specific get operation
-     * @returns The cached or newly computed value
-     * @throws Error if the cached value is a promise (use getOrInsertAsync
-     *   instead)
-     */
-    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"
-        );
-      }
-      refreshEntry(cacheKey, now);
-      return entry.value;
-    },
-    /**
-     * Gets a value from the cache or computes and stores it asynchronously.
-     * Provides promise deduplication - concurrent calls with the same key will
-     * share the same promise.
-     *
-     * @param cacheKey - Unique key to identify the cached value
-     * @param val - Async function that computes the value if not cached.
-     *   Receives utility functions for advanced features.
-     * @param options - Optional configuration for this specific get operation
-     * @returns Promise that resolves to the cached or newly computed 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)) {
-        refreshEntry(cacheKey, 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;
-    },
-    /** Removes all items from the cache. */
-    clear() {
-      cache.clear();
-    },
-    /**
-     * Gets a value from the cache without computing it if missing. Returns
-     * undefined if the key doesn't exist or has expired.
-     *
-     * @param cacheKey - Key to look up in the cache
-     * @returns The cached value or undefined if not found/expired
-     * @throws Error if the cached value is a promise (use getAsync instead)
-     */
-    get(cacheKey) {
-      const entry = cache.get(cacheKey);
-      const now = Date.now();
-      if (!entry || isExpired(entry, now)) {
-        return void 0;
-      }
-      if (isPromise(entry.value)) {
-        throw new Error("Cache value is a promise, use getAsync instead");
-      }
-      refreshEntry(cacheKey, now);
-      return entry.value;
-    },
-    /**
-     * Manually sets a value in the cache.
-     *
-     * @param cacheKey - Key to store the value under
-     * @param value - Value to store, or WithExpiration wrapper for custom
-     *   expiration
-     */
-    set(cacheKey, value) {
-      cache.set(cacheKey, unwrapValue(value, Date.now()));
-      trimToSize();
-      cleanExpiredItems();
-    },
-    /**
-     * Gets a value from the cache without computing it if missing. Works with
-     * both sync and async cached values.
-     *
-     * @param cacheKey - Key to look up in the cache
-     * @returns Promise that resolves to the cached value or undefined if not
-     *   found/expired
-     */
-    async getAsync(cacheKey) {
-      const entry = cache.get(cacheKey);
-      const now = Date.now();
-      if (!entry || isExpired(entry, now)) {
-        return void 0;
-      }
-      refreshEntry(cacheKey, now);
-      return entry.value;
-    },
-    /**
-     * Manually sets an async value in the cache. The promise will be stored
-     * immediately and shared with concurrent requests.
-     *
-     * @param cacheKey - Key to store the value under
-     * @param value - Async function that returns the value to cache
-     * @returns Promise that resolves to the computed 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;
-    },
-    /**
-     * Manually triggers cleanup of expired items. Normally this happens
-     * automatically during cache operations.
-     */
-    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)) {
-      const value = val();
-      cache.set(cacheKey, value);
-      trimCache();
-      return cache.get(cacheKey) ?? value;
-    }
-    return cache.get(cacheKey);
-  }
-  return {
-    getOrInsert,
-    /** Clears all cached values */
-    clear: () => cache.clear()
-  };
-}
-
-export {
-  cachedGetter,
-  SkipCaching,
-  WithExpiration,
-  createCache,
-  fastCache
-};

package/dist/chunk-GMJTLFM6.js

@@ -1,60 +0,0 @@
-// src/typingFnUtils.ts
-function asNonPartial(obj) {
-  return obj;
-}
-function typedObjectEntries(obj) {
-  return Object.entries(obj);
-}
-function strictTypedObjectEntries(obj) {
-  return Object.entries(obj);
-}
-function typedObjectKeys(obj) {
-  return Object.keys(obj);
-}
-function asType(value) {
-  return value;
-}
-function narrowStringToUnion(key, union) {
-  if (!key) return void 0;
-  if (union instanceof Set) {
-    return union.has(key) ? key : void 0;
-  }
-  if (union.includes(key)) {
-    return key;
-  }
-  return void 0;
-}
-function typeOnRightExtendsLeftType() {
-  return void 0;
-}
-var isSubTypeOf = typeOnRightExtendsLeftType;
-function isObjKey(key, obj) {
-  return typeof key === "string" && key in obj;
-}
-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,
-  typeOnRightExtendsLeftType,
-  isSubTypeOf,
-  isObjKey,
-  unionsAreTheSame,
-  asPartialUndefinedValues,
-  isNonEmptyArray,
-  objectHasKey
-};

package/dist/chunk-IATIXMCE.js

@@ -1,20 +0,0 @@
-// src/conversions.ts
-function bytesToHumanReadable(bytes) {
-  if (bytes < 1024) {
-    return `${bytes} B`;
-  }
-  const kb = bytes / 1024;
-  if (kb < 1024) {
-    return `${kb.toFixed(2)} KB`;
-  }
-  const mb = kb / 1024;
-  if (mb < 1024) {
-    return `${mb.toFixed(2)} MB`;
-  }
-  const gb = mb / 1024;
-  return `${gb.toFixed(2)} GB`;
-}
-
-export {
-  bytesToHumanReadable
-};

package/dist/chunk-II4R3VVX.js

@@ -1,25 +0,0 @@
-// src/castValues.ts
-function castToString(value) {
-  const valueType = typeof value;
-  return valueType === "string" || valueType === "number" || valueType === "boolean" || valueType === "bigint" ? String(value) : null;
-}
-function castToNumber(value) {
-  return isFiniteNumeric(value) ? Number(value) : null;
-}
-function isFiniteNumeric(num) {
-  switch (typeof num) {
-    case "number":
-      return num - num === 0;
-    case "string":
-      return num.trim() !== "" && Number.isFinite(+num);
-    case "bigint":
-      return Number.isFinite(Number(num));
-    default:
-      return false;
-  }
-}
-
-export {
-  castToString,
-  castToNumber
-};

package/dist/chunk-JF2MDHOJ.js

@@ -1,40 +0,0 @@
-// src/typeGuards.ts
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function isPromise(value) {
-  return isObject(value) && "then" in value && isFunction(value.then);
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") return false;
-  const proto = Object.getPrototypeOf(value);
-  if (proto === null) {
-    return true;
-  }
-  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  if (Ctor === Object) return true;
-  const objectCtorString = Object.prototype.constructor.toString();
-  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
-}
-function isNonEmptyArray(value) {
-  return value.length > 0;
-}
-function arrayHasAtLeastXItems(array, minLength) {
-  return array.length >= minLength;
-}
-function isTruthy(value) {
-  return !!value;
-}
-
-export {
-  isObject,
-  isFunction,
-  isPromise,
-  isPlainObject,
-  isNonEmptyArray,
-  arrayHasAtLeastXItems,
-  isTruthy
-};

package/dist/chunk-JQFUKJU5.js

@@ -1,71 +0,0 @@
-// src/deepEqual.ts
-var has = Object.prototype.hasOwnProperty;
-function find(iter, tar, maxDepth) {
-  for (const key of iter.keys()) {
-    if (deepEqual(key, tar, maxDepth)) return key;
-  }
-}
-function deepEqual(foo, bar, maxDepth = 20) {
-  let ctor, len, tmp;
-  if (foo === bar) return true;
-  if (maxDepth && maxDepth <= 0) return false;
-  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
-    if (ctor === Date)
-      return deepEqual(foo.getTime(), bar.getTime(), maxDepth - 1);
-    if (ctor === RegExp) return foo.toString() === bar.toString();
-    if (ctor === Array) {
-      if ((len = foo.length) === bar.length) {
-        while (len-- && deepEqual(foo[len], bar[len], maxDepth - 1)) ;
-      }
-      return len === -1;
-    }
-    if (ctor === Set) {
-      if (foo.size !== bar.size) {
-        return false;
-      }
-      for (len of foo) {
-        tmp = len;
-        if (tmp && typeof tmp === "object") {
-          tmp = find(bar, tmp, maxDepth - 1);
-          if (!tmp) return false;
-        }
-        if (!bar.has(tmp)) return false;
-      }
-      return true;
-    }
-    if (ctor === Map) {
-      if (foo.size !== bar.size) {
-        return false;
-      }
-      for (len of foo) {
-        tmp = len[0];
-        if (tmp && typeof tmp === "object") {
-          tmp = find(bar, tmp, maxDepth - 1);
-          if (!tmp) return false;
-        }
-        if (!deepEqual(len[1], bar.get(tmp), maxDepth - 1)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (!ctor || typeof foo === "object") {
-      len = 0;
-      for (ctor in foo) {
-        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
-        if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor], maxDepth - 1))
-          return false;
-      }
-      return Object.keys(bar).length === len;
-    }
-  }
-  return foo !== foo && bar !== bar;
-}
-function deepEqualWithMaxDepth(maxDepth) {
-  return (foo, bar) => deepEqual(foo, bar, maxDepth);
-}
-
-export {
-  deepEqual,
-  deepEqualWithMaxDepth
-};