@ls-stack/utils 3.65.0 → 3.67.0

package/dist/dedent.d.cts

@@ -1,73 +0,0 @@
-/** Configuration options for the dedent function behavior */
-interface DedentOptions {
-    /**
-     * Whether to process escape sequences like \n, `, $, and { When true, allows
-     * using escaped characters in template literals
-     *
-     * @default true for template literals, false for plain strings
-     */
-    escapeSpecialCharacters?: boolean;
-    /**
-     * Whether to trim leading and trailing whitespace from the final result
-     *
-     * @default true
-     */
-    trimWhitespace?: boolean;
-    /**
-     * Whether to preserve relative indentation of interpolated multi-line values
-     * When true, multi-line interpolations are re-indented to match the
-     * surrounding context
-     *
-     * @default true
-     */
-    identInterpolations?: boolean;
-    /**
-     * Whether to display nullish or false values (false, null, undefined) in
-     * interpolations When false, nullish or false values are skipped entirely
-     *
-     * @default false
-     */
-    showNullishOrFalseValues?: boolean;
-}
-type InterpolationValue = string | number | boolean | null | undefined;
-/**
- * Dedent function interface that can be used both as a template tag and a
- * regular function
- */
-interface Dedent {
-    /** Process a plain string to remove common indentation */
-    (literals: string): string;
-    /**
-     * Process a template literal to remove common indentation while handling
-     * interpolations
-     */
-    (strings: TemplateStringsArray, ...values: InterpolationValue[]): string;
-    /** Create a new dedent function with custom options */
-    withOptions: CreateDedent;
-}
-/** Factory function type for creating dedent functions with custom options */
-type CreateDedent = (options: DedentOptions) => Dedent;
-/**
- * Remove common leading indentation from multi-line strings while preserving
- * relative indentation. Can be used as a tagged template literal or called with
- * a plain string.
- *
- * By default, it will dedent interpolated multi-line strings to match the
- * surrounding context. And it will not show falsy values.
- *
- * @example
- *   ```typescript
- *   const text = dedent`;
- *   function hello() {
- *     console.log('world');
- *   }
- *   `;
- *   // Result:
- *   "function hello() {
- *     console.log('world');
- *   }"
- *   ```;
- */
-declare const dedent: Dedent;
-
-export { type CreateDedent, type Dedent, type DedentOptions, dedent };

package/dist/dedent.d.ts

@@ -1,73 +0,0 @@
-/** Configuration options for the dedent function behavior */
-interface DedentOptions {
-    /**
-     * Whether to process escape sequences like \n, `, $, and { When true, allows
-     * using escaped characters in template literals
-     *
-     * @default true for template literals, false for plain strings
-     */
-    escapeSpecialCharacters?: boolean;
-    /**
-     * Whether to trim leading and trailing whitespace from the final result
-     *
-     * @default true
-     */
-    trimWhitespace?: boolean;
-    /**
-     * Whether to preserve relative indentation of interpolated multi-line values
-     * When true, multi-line interpolations are re-indented to match the
-     * surrounding context
-     *
-     * @default true
-     */
-    identInterpolations?: boolean;
-    /**
-     * Whether to display nullish or false values (false, null, undefined) in
-     * interpolations When false, nullish or false values are skipped entirely
-     *
-     * @default false
-     */
-    showNullishOrFalseValues?: boolean;
-}
-type InterpolationValue = string | number | boolean | null | undefined;
-/**
- * Dedent function interface that can be used both as a template tag and a
- * regular function
- */
-interface Dedent {
-    /** Process a plain string to remove common indentation */
-    (literals: string): string;
-    /**
-     * Process a template literal to remove common indentation while handling
-     * interpolations
-     */
-    (strings: TemplateStringsArray, ...values: InterpolationValue[]): string;
-    /** Create a new dedent function with custom options */
-    withOptions: CreateDedent;
-}
-/** Factory function type for creating dedent functions with custom options */
-type CreateDedent = (options: DedentOptions) => Dedent;
-/**
- * Remove common leading indentation from multi-line strings while preserving
- * relative indentation. Can be used as a tagged template literal or called with
- * a plain string.
- *
- * By default, it will dedent interpolated multi-line strings to match the
- * surrounding context. And it will not show falsy values.
- *
- * @example
- *   ```typescript
- *   const text = dedent`;
- *   function hello() {
- *     console.log('world');
- *   }
- *   `;
- *   // Result:
- *   "function hello() {
- *     console.log('world');
- *   }"
- *   ```;
- */
-declare const dedent: Dedent;
-
-export { type CreateDedent, type Dedent, type DedentOptions, dedent };

package/dist/dedent.js

@@ -1,79 +0,0 @@
-// src/dedent.ts
-var dedent = createDedent({
-  identInterpolations: true
-});
-function createDedent(options) {
-  d.withOptions = (newOptions) => createDedent({ ...options, ...newOptions });
-  return d;
-  function d(strings, ...values) {
-    const raw = typeof strings === "string" ? [strings] : strings.raw;
-    const {
-      escapeSpecialCharacters = Array.isArray(strings),
-      trimWhitespace = true,
-      identInterpolations = true,
-      showNullishOrFalseValues = false
-    } = options;
-    let result = "";
-    for (let i = 0; i < raw.length; i++) {
-      let next = raw[i];
-      if (escapeSpecialCharacters) {
-        next = next.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{");
-      }
-      result += next;
-      if (i < values.length) {
-        let val = values[i];
-        if (!showNullishOrFalseValues && (val === false || val === null || val === void 0)) {
-          continue;
-        }
-        val = String(val);
-        if (identInterpolations && val.includes("\n")) {
-          let withIdent = val;
-          const currentIndent = getCurrentIndent(result);
-          if (currentIndent && withIdent) {
-            const lines2 = withIdent.split("\n");
-            withIdent = lines2.map((line, index) => {
-              return index === 0 || line === "" ? line : currentIndent + line;
-            }).join("\n");
-          }
-          result += withIdent;
-        } else {
-          result += val;
-        }
-      }
-    }
-    const lines = result.split("\n");
-    let mindent = null;
-    for (const l of lines) {
-      const m = l.match(/^(\s+)\S+/);
-      if (m) {
-        const indent = m[1].length;
-        if (!mindent) {
-          mindent = indent;
-        } else {
-          mindent = Math.min(mindent, indent);
-        }
-      }
-    }
-    if (mindent !== null) {
-      const m = mindent;
-      result = lines.map((l) => l[0] === " " || l[0] === "	" ? l.slice(m) : l).join("\n");
-    }
-    if (trimWhitespace) {
-      result = result.trim();
-    }
-    if (escapeSpecialCharacters) {
-      result = result.replace(/\\n/g, "\n");
-    }
-    return result;
-  }
-}
-function getCurrentIndent(str) {
-  const lines = str.split("\n");
-  const lastLine = lines[lines.length - 1];
-  if (!lastLine) return "";
-  const match = lastLine.match(/^(\s*)/);
-  return match ? match[1] : "";
-}
-export {
-  dedent
-};

package/dist/deepEqual.cjs

@@ -1,96 +0,0 @@
-"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/deepEqual.ts
-var deepEqual_exports = {};
-__export(deepEqual_exports, {
-  deepEqual: () => deepEqual,
-  deepEqualWithMaxDepth: () => deepEqualWithMaxDepth
-});
-module.exports = __toCommonJS(deepEqual_exports);
-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);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  deepEqual,
-  deepEqualWithMaxDepth
-});

package/dist/deepEqual.d.ts

@@ -1,21 +0,0 @@
-/**
- * Deep equality comparison between two values
- *
- * @example
- *   ```ts
- *   deepEqual({a: 1}, {a: 1}) // true
- *   deepEqual({a: 1}, {a: 2}) // false
- *   deepEqual([1, {b: 2}], [1, {b: 2}]) // true
- *   deepEqual(new Map([['a', 1]]), new Map([['a', 1]])) // true
- *   deepEqual(new Set([1, 2]), new Set([1, 2])) // true
- *   ```;
- *
- * @param foo First value to compare
- * @param bar Second value to compare
- * @param maxDepth Maximum comparison depth (default: 20)
- * @returns True if values are deeply equal, false otherwise
- */
-declare function deepEqual(foo: any, bar: any, maxDepth?: number): boolean;
-declare function deepEqualWithMaxDepth(maxDepth: number): (foo: any, bar: any) => boolean;
-
-export { deepEqual, deepEqualWithMaxDepth };

package/dist/deepEqual.js

@@ -1,8 +0,0 @@
-import {
-  deepEqual,
-  deepEqualWithMaxDepth
-} from "./chunk-JQFUKJU5.js";
-export {
-  deepEqual,
-  deepEqualWithMaxDepth
-};

package/dist/deepReplaceValues.cjs

@@ -1,87 +0,0 @@
-"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/deepReplaceValues.ts
-var deepReplaceValues_exports = {};
-__export(deepReplaceValues_exports, {
-  deepReplaceValues: () => deepReplaceValues
-});
-module.exports = __toCommonJS(deepReplaceValues_exports);
-
-// src/typeGuards.ts
-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;
-}
-
-// src/deepReplaceValues.ts
-function applyValueReplacements(value, replaceValues, visited, currentPath) {
-  function processValue(val, path) {
-    const replacement = replaceValues(val, path);
-    if (replacement !== false) {
-      return replacement.newValue;
-    }
-    if (Array.isArray(val)) {
-      if (visited.has(val)) {
-        throw new Error("Circular reference detected in array");
-      }
-      visited.add(val);
-      try {
-        return val.map((item, index) => {
-          const itemPath = path ? `${path}[${index}]` : `[${index}]`;
-          return processValue(item, itemPath);
-        });
-      } finally {
-        visited.delete(val);
-      }
-    }
-    if (isPlainObject(val)) {
-      if (visited.has(val)) {
-        throw new Error("Circular reference detected in object");
-      }
-      visited.add(val);
-      try {
-        const result = {};
-        for (const [key, itemValue] of Object.entries(val)) {
-          const itemPath = path ? `${path}.${key}` : key;
-          result[key] = processValue(itemValue, itemPath);
-        }
-        return result;
-      } finally {
-        visited.delete(val);
-      }
-    }
-    return val;
-  }
-  return processValue(value, currentPath);
-}
-function deepReplaceValues(value, replaceValues) {
-  return applyValueReplacements(value, replaceValues, /* @__PURE__ */ new Set(), "");
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  deepReplaceValues
-});

package/dist/deepReplaceValues.d.ts

@@ -1,27 +0,0 @@
-/**
- * Recursively traverses an object or array and allows conditional replacement of values
- * based on a provided callback function. The callback receives each value and its path
- * within the data structure.
- *
- * @param value - The input value to process (object, array, or primitive)
- * @param replaceValues - Callback function that receives each value and its path.
- *   Return `false` to keep the original value, or `{ newValue: unknown }` to replace it.
- *   The path uses dot notation for objects (e.g., "user.name") and bracket notation for arrays (e.g., "items[0]")
- * @returns A new structure with replaced values. The original structure is not modified.
- * @throws Error if circular references are detected
- *
- * @example
- * const data = { user: { id: 1, name: "Alice" }, scores: [85, 92] };
- * const result = deepReplaceValues(data, (value, path) => {
- *   if (typeof value === "number") {
- *     return { newValue: value * 2 };
- *   }
- *   return false;
- * });
- * // Result: { user: { id: 2, name: "Alice" }, scores: [170, 184] }
- */
-declare function deepReplaceValues<T, R = T>(value: T, replaceValues: (value: unknown, path: string) => false | {
-    newValue: unknown;
-}): R;
-
-export { deepReplaceValues };

package/dist/deepReplaceValues.js

@@ -1,7 +0,0 @@
-import {
-  deepReplaceValues
-} from "./chunk-PUKVXYYL.js";
-import "./chunk-JF2MDHOJ.js";
-export {
-  deepReplaceValues
-};

package/dist/enhancedMap.cjs

@@ -1,131 +0,0 @@
-"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/enhancedMap.ts
-var enhancedMap_exports = {};
-__export(enhancedMap_exports, {
-  EnhancedMap: () => EnhancedMap,
-  enhancedMapReject: () => enhancedMapReject
-});
-module.exports = __toCommonJS(enhancedMap_exports);
-
-// src/typeGuards.ts
-function isFunction(value) {
-  return typeof value === "function";
-}
-
-// src/assertions.ts
-var isFunction2 = isFunction;
-
-// src/enhancedMap.ts
-var enhancedMapReject = Symbol();
-var EnhancedMap = class _EnhancedMap extends Map {
-  find(predicate) {
-    for (const [key, value] of this) {
-      if (predicate(value, key)) {
-        return { key, value };
-      }
-    }
-    return void 0;
-  }
-  setMultiple(...values) {
-    if (Array.isArray(values[0])) {
-      for (const [key, value] of values) {
-        this.set(key, value);
-      }
-    } else {
-      for (const [key, value] of Object.entries(values[0])) {
-        this.set(key, value);
-      }
-    }
-    return this;
-  }
-  getOrThrow(key) {
-    const value = this.get(key);
-    if (value === void 0) {
-      throw new Error(`Key ${key} not found in EnhancedMap`);
-    }
-    return value;
-  }
-  getOrInsert(key, fallback) {
-    if (!this.has(key)) {
-      this.set(key, fallback());
-    }
-    return this.getOrThrow(key);
-  }
-  toFilteredValues(predicate) {
-    const values = [];
-    for (const [key, value] of this) {
-      if (predicate(value, key)) {
-        values.push(value);
-      }
-    }
-    return values;
-  }
-  toMap(mapFunction) {
-    const values = [];
-    for (const [key, value] of this) {
-      const result = mapFunction(value, key, enhancedMapReject);
-      if (result !== enhancedMapReject) {
-        values.push(result);
-      }
-    }
-    return values;
-  }
-  toObjMap(mapFunction) {
-    const values = {};
-    for (const [key, value] of this) {
-      const result = mapFunction(value, key);
-      if (result) {
-        values[result[0]] = result[1];
-      }
-    }
-    return values;
-  }
-  toValues() {
-    return [...this.values()];
-  }
-  toKeys() {
-    return [...this.keys()];
-  }
-  static from(array, mapFunction) {
-    const map = new _EnhancedMap();
-    if (!array) return map;
-    const isFn = isFunction2(mapFunction);
-    for (const item of array) {
-      if (isFn) {
-        const result = mapFunction(item);
-        if (result) {
-          map.set(result[0], result[1]);
-        }
-      } else {
-        const key = item[mapFunction];
-        if (key !== void 0) {
-          map.set(key, item);
-        }
-      }
-    }
-    return map;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  EnhancedMap,
-  enhancedMapReject
-});

package/dist/enhancedMap.d.cts

@@ -1,20 +0,0 @@
-declare const enhancedMapReject: unique symbol;
-declare class EnhancedMap<K, V> extends Map<K, V> {
-    find(predicate: (value: V, key: K) => boolean): {
-        key: K;
-        value: V;
-    } | undefined;
-    setMultiple(values: Record<K & string, V>): this;
-    setMultiple(...values: [key: K, value: V][]): this;
-    getOrThrow(key: K): V;
-    getOrInsert(key: K, fallback: () => V): V;
-    toFilteredValues(predicate: (value: V, key: K) => boolean): V[];
-    toMap<T>(mapFunction: (value: V, key: K, reject: typeof enhancedMapReject) => T | typeof enhancedMapReject): T[];
-    toObjMap<ObjKey extends PropertyKey, ObjValue>(mapFunction: (value: V, key: K) => [key: ObjKey, value: ObjValue] | false): Record<ObjKey, ObjValue>;
-    toValues(): V[];
-    toKeys(): K[];
-    static from<T extends Record<string, unknown>, K extends keyof T>(array: T[] | Iterable<T> | null | undefined, key: K): EnhancedMap<T[K], T>;
-    static from<T, K, V>(array: T[] | Iterable<T> | null | undefined, mapFunction: (item: T) => [key: K, value: V] | false): EnhancedMap<K, V>;
-}
-
-export { EnhancedMap, enhancedMapReject };

package/dist/enhancedMap.d.ts

@@ -1,20 +0,0 @@
-declare const enhancedMapReject: unique symbol;
-declare class EnhancedMap<K, V> extends Map<K, V> {
-    find(predicate: (value: V, key: K) => boolean): {
-        key: K;
-        value: V;
-    } | undefined;
-    setMultiple(values: Record<K & string, V>): this;
-    setMultiple(...values: [key: K, value: V][]): this;
-    getOrThrow(key: K): V;
-    getOrInsert(key: K, fallback: () => V): V;
-    toFilteredValues(predicate: (value: V, key: K) => boolean): V[];
-    toMap<T>(mapFunction: (value: V, key: K, reject: typeof enhancedMapReject) => T | typeof enhancedMapReject): T[];
-    toObjMap<ObjKey extends PropertyKey, ObjValue>(mapFunction: (value: V, key: K) => [key: ObjKey, value: ObjValue] | false): Record<ObjKey, ObjValue>;
-    toValues(): V[];
-    toKeys(): K[];
-    static from<T extends Record<string, unknown>, K extends keyof T>(array: T[] | Iterable<T> | null | undefined, key: K): EnhancedMap<T[K], T>;
-    static from<T, K, V>(array: T[] | Iterable<T> | null | undefined, mapFunction: (item: T) => [key: K, value: V] | false): EnhancedMap<K, V>;
-}
-
-export { EnhancedMap, enhancedMapReject };

package/dist/enhancedMap.js

@@ -1,10 +0,0 @@
-import {
-  EnhancedMap,
-  enhancedMapReject
-} from "./chunk-7CQPOM5I.js";
-import "./chunk-C2SVCIWE.js";
-import "./chunk-JF2MDHOJ.js";
-export {
-  EnhancedMap,
-  enhancedMapReject
-};