@ls-stack/utils 3.18.0 → 3.20.0

package/lib/chunk-NW5H5EW7.js

@@ -0,0 +1,100 @@
+// src/debounce.ts
+function debounce(func, wait, options) {
+  let lastArgs;
+  let lastThis;
+  let maxWait;
+  let result;
+  let timerId;
+  let lastCallTime;
+  let lastInvokeTime = 0;
+  let leading = false;
+  let maxing = false;
+  let trailing = true;
+  if (options) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    const timeSinceLastCall = time - (lastCallTime ?? 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    const timeWaiting = wait - timeSinceLastCall;
+    return maxing ? Math.min(timeWaiting, (maxWait ?? 0) - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    const timeSinceLastCall = time - (lastCallTime ?? 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= (maxWait ?? 0);
+  }
+  function timerExpired() {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(Date.now());
+  }
+  function debounced() {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+function isDebouncedFn(fn) {
+  return typeof fn === "function" && "cancel" in fn && "flush" in fn;
+}
+
+export {
+  debounce,
+  isDebouncedFn
+};

package/lib/{chunk-DMW5Q4T2.js → chunk-SRVMMYSW.js}

@@ -1,6 +1,6 @@
 import {
   isFunction
-} from "./chunk-WS4WEVHU.js";
+} from "./chunk-C2SVCIWE.js";
 
 // src/arrayUtils.ts
 function filterAndMap(array, mapFilter) {

package/lib/concurrentCalls.js

@@ -6,12 +6,12 @@ import {
 } from "./chunk-5DZT3Z5Z.js";
 import {
   truncateArray
-} from "./chunk-DMW5Q4T2.js";
+} from "./chunk-SRVMMYSW.js";
 import {
   invariant,
   isPromise
-} from "./chunk-WS4WEVHU.js";
-import "./chunk-SSKW673U.js";
+} from "./chunk-C2SVCIWE.js";
+import "./chunk-JF2MDHOJ.js";
 
 // src/concurrentCalls.ts
 import { Result, resultify, unknownToError } from "t-result";

package/lib/createThrottleController.js

@@ -1,13 +1,13 @@
 import {
   EnhancedMap
-} from "./chunk-GKOTKAIV.js";
+} from "./chunk-7CQPOM5I.js";
 import {
   durationObjToMs
 } from "./chunk-5MNYPLZI.js";
 import "./chunk-HTCYUMDR.js";
 import "./chunk-II4R3VVX.js";
-import "./chunk-WS4WEVHU.js";
-import "./chunk-SSKW673U.js";
+import "./chunk-C2SVCIWE.js";
+import "./chunk-JF2MDHOJ.js";
 
 // src/createThrottleController.ts
 function createThrottleController({

package/lib/debounce.js

@@ -1,98 +1,7 @@
-// src/debounce.ts
-function debounce(func, wait, options) {
-  let lastArgs;
-  let lastThis;
-  let maxWait;
-  let result;
-  let timerId;
-  let lastCallTime;
-  let lastInvokeTime = 0;
-  let leading = false;
-  let maxing = false;
-  let trailing = true;
-  if (options) {
-    leading = !!options.leading;
-    maxing = "maxWait" in options;
-    maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;
-    trailing = "trailing" in options ? !!options.trailing : trailing;
-  }
-  function invokeFunc(time) {
-    const args = lastArgs;
-    const thisArg = lastThis;
-    lastArgs = lastThis = void 0;
-    lastInvokeTime = time;
-    result = func.apply(thisArg, args);
-    return result;
-  }
-  function leadingEdge(time) {
-    lastInvokeTime = time;
-    timerId = setTimeout(timerExpired, wait);
-    return leading ? invokeFunc(time) : result;
-  }
-  function remainingWait(time) {
-    const timeSinceLastCall = time - (lastCallTime ?? 0);
-    const timeSinceLastInvoke = time - lastInvokeTime;
-    const timeWaiting = wait - timeSinceLastCall;
-    return maxing ? Math.min(timeWaiting, (maxWait ?? 0) - timeSinceLastInvoke) : timeWaiting;
-  }
-  function shouldInvoke(time) {
-    const timeSinceLastCall = time - (lastCallTime ?? 0);
-    const timeSinceLastInvoke = time - lastInvokeTime;
-    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= (maxWait ?? 0);
-  }
-  function timerExpired() {
-    const time = Date.now();
-    if (shouldInvoke(time)) {
-      return trailingEdge(time);
-    }
-    timerId = setTimeout(timerExpired, remainingWait(time));
-  }
-  function trailingEdge(time) {
-    timerId = void 0;
-    if (trailing && lastArgs) {
-      return invokeFunc(time);
-    }
-    lastArgs = lastThis = void 0;
-    return result;
-  }
-  function cancel() {
-    if (timerId !== void 0) {
-      clearTimeout(timerId);
-    }
-    lastInvokeTime = 0;
-    lastArgs = lastCallTime = lastThis = timerId = void 0;
-  }
-  function flush() {
-    return timerId === void 0 ? result : trailingEdge(Date.now());
-  }
-  function debounced() {
-    const time = Date.now();
-    const isInvoking = shouldInvoke(time);
-    lastArgs = arguments;
-    lastThis = this;
-    lastCallTime = time;
-    if (isInvoking) {
-      if (timerId === void 0) {
-        return leadingEdge(lastCallTime);
-      }
-      if (maxing) {
-        clearTimeout(timerId);
-        timerId = setTimeout(timerExpired, wait);
-        return invokeFunc(lastCallTime);
-      }
-    }
-    if (timerId === void 0) {
-      timerId = setTimeout(timerExpired, wait);
-    }
-    return result;
-  }
-  debounced.cancel = cancel;
-  debounced.flush = flush;
-  return debounced;
-}
-function isDebouncedFn(fn) {
-  return typeof fn === "function" && "cancel" in fn && "flush" in fn;
-}
+import {
+  debounce,
+  isDebouncedFn
+} from "./chunk-NW5H5EW7.js";
 export {
   debounce,
   isDebouncedFn

package/lib/dedent.cjs

@@ -23,7 +23,9 @@ __export(dedent_exports, {
   dedent: () => dedent
 });
 module.exports = __toCommonJS(dedent_exports);
-var dedent = createDedent({});
+var dedent = createDedent({
+  identInterpolations: true
+});
 function createDedent(options) {
   d.withOptions = (newOptions) => createDedent({ ...options, ...newOptions });
   return d;
@@ -31,7 +33,9 @@ function createDedent(options) {
     const raw = typeof strings === "string" ? [strings] : strings.raw;
     const {
       escapeSpecialCharacters = Array.isArray(strings),
-      trimWhitespace = true
+      trimWhitespace = true,
+      identInterpolations = true,
+      showNullishOrFalseValues = false
     } = options;
     let result = "";
     for (let i = 0; i < raw.length; i++) {
@@ -41,7 +45,24 @@ function createDedent(options) {
       }
       result += next;
       if (i < values.length) {
-        result += values[i];
+        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");
@@ -70,6 +91,13 @@ function createDedent(options) {
     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] : "";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   dedent

package/lib/dedent.d.cts

@@ -1,13 +1,73 @@
+/**
+ * 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;
-    (strings: TemplateStringsArray, ...values: unknown[]): 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/lib/dedent.d.ts

@@ -1,13 +1,73 @@
+/**
+ * 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;
-    (strings: TemplateStringsArray, ...values: unknown[]): 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/lib/dedent.js

@@ -1,5 +1,7 @@
 // src/dedent.ts
-var dedent = createDedent({});
+var dedent = createDedent({
+  identInterpolations: true
+});
 function createDedent(options) {
   d.withOptions = (newOptions) => createDedent({ ...options, ...newOptions });
   return d;
@@ -7,7 +9,9 @@ function createDedent(options) {
     const raw = typeof strings === "string" ? [strings] : strings.raw;
     const {
       escapeSpecialCharacters = Array.isArray(strings),
-      trimWhitespace = true
+      trimWhitespace = true,
+      identInterpolations = true,
+      showNullishOrFalseValues = false
     } = options;
     let result = "";
     for (let i = 0; i < raw.length; i++) {
@@ -17,7 +21,24 @@ function createDedent(options) {
       }
       result += next;
       if (i < values.length) {
-        result += values[i];
+        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");
@@ -46,6 +67,13 @@ function createDedent(options) {
     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/lib/enhancedMap.js

@@ -1,9 +1,9 @@
 import {
   EnhancedMap,
   enhancedMapReject
-} from "./chunk-GKOTKAIV.js";
-import "./chunk-WS4WEVHU.js";
-import "./chunk-SSKW673U.js";
+} from "./chunk-7CQPOM5I.js";
+import "./chunk-C2SVCIWE.js";
+import "./chunk-JF2MDHOJ.js";
 export {
   EnhancedMap,
   enhancedMapReject

package/lib/getAutoIncrementId.cjs

@@ -0,0 +1,44 @@
+"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/getAutoIncrementId.ts
+var getAutoIncrementId_exports = {};
+__export(getAutoIncrementId_exports, {
+  getAutoIncrementId: () => getAutoIncrementId,
+  getLocalAutoIncrementIdGenerator: () => getLocalAutoIncrementIdGenerator
+});
+module.exports = __toCommonJS(getAutoIncrementId_exports);
+var id = 1;
+function getAutoIncrementId() {
+  return id++;
+}
+function getLocalAutoIncrementIdGenerator({
+  prefix,
+  suffix
+}) {
+  let localId = 1;
+  return () => {
+    return `${prefix || ""}${localId++}${suffix || ""}`;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAutoIncrementId,
+  getLocalAutoIncrementIdGenerator
+});

package/lib/getAutoIncrementId.d.cts

@@ -0,0 +1,44 @@
+/**
+ * Returns a unique auto-incrementing number each time it's called.
+ * This is useful for generating simple unique identifiers within a single session/process.
+ *
+ * **Note:** This is not suitable for distributed systems or persistent storage.
+ * For cryptographically secure or collision-resistant IDs, use `nanoid()` instead.
+ *
+ * @returns A unique incrementing number starting from 1
+ *
+ * @example
+ * ```ts
+ * const id1 = getAutoIncrementId(); // 1
+ * const id2 = getAutoIncrementId(); // 2
+ * const id3 = getAutoIncrementId(); // 3
+ * ```
+ */
+declare function getAutoIncrementId(): number;
+/**
+ * Creates a local auto-increment ID generator with optional prefix and suffix.
+ * Each generator maintains its own independent counter starting from 1.
+ * This is useful when you need multiple independent ID sequences or formatted IDs.
+ *
+ * @param options - Configuration object
+ * @param options.prefix - Optional prefix to prepend to each generated ID
+ * @param options.suffix - Optional suffix to append to each generated ID
+ * @returns A function that generates formatted auto-increment IDs
+ *
+ * @example
+ * ```ts
+ * const userIdGen = getLocalAutoIncrementIdGenerator({ prefix: 'user-' });
+ * const postIdGen = getLocalAutoIncrementIdGenerator({ prefix: 'post-', suffix: '-draft' });
+ *
+ * console.log(userIdGen()); // "user-1"
+ * console.log(userIdGen()); // "user-2"
+ * console.log(postIdGen()); // "post-1-draft"
+ * console.log(postIdGen()); // "post-2-draft"
+ * ```
+ */
+declare function getLocalAutoIncrementIdGenerator({ prefix, suffix, }: {
+    prefix?: string;
+    suffix?: string;
+}): () => string;
+
+export { getAutoIncrementId, getLocalAutoIncrementIdGenerator };

package/lib/getAutoIncrementId.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Returns a unique auto-incrementing number each time it's called.
+ * This is useful for generating simple unique identifiers within a single session/process.
+ *
+ * **Note:** This is not suitable for distributed systems or persistent storage.
+ * For cryptographically secure or collision-resistant IDs, use `nanoid()` instead.
+ *
+ * @returns A unique incrementing number starting from 1
+ *
+ * @example
+ * ```ts
+ * const id1 = getAutoIncrementId(); // 1
+ * const id2 = getAutoIncrementId(); // 2
+ * const id3 = getAutoIncrementId(); // 3
+ * ```
+ */
+declare function getAutoIncrementId(): number;
+/**
+ * Creates a local auto-increment ID generator with optional prefix and suffix.
+ * Each generator maintains its own independent counter starting from 1.
+ * This is useful when you need multiple independent ID sequences or formatted IDs.
+ *
+ * @param options - Configuration object
+ * @param options.prefix - Optional prefix to prepend to each generated ID
+ * @param options.suffix - Optional suffix to append to each generated ID
+ * @returns A function that generates formatted auto-increment IDs
+ *
+ * @example
+ * ```ts
+ * const userIdGen = getLocalAutoIncrementIdGenerator({ prefix: 'user-' });
+ * const postIdGen = getLocalAutoIncrementIdGenerator({ prefix: 'post-', suffix: '-draft' });
+ *
+ * console.log(userIdGen()); // "user-1"
+ * console.log(userIdGen()); // "user-2"
+ * console.log(postIdGen()); // "post-1-draft"
+ * console.log(postIdGen()); // "post-2-draft"
+ * ```
+ */
+declare function getLocalAutoIncrementIdGenerator({ prefix, suffix, }: {
+    prefix?: string;
+    suffix?: string;
+}): () => string;
+
+export { getAutoIncrementId, getLocalAutoIncrementIdGenerator };

package/lib/getAutoIncrementId.js

@@ -0,0 +1,18 @@
+// src/getAutoIncrementId.ts
+var id = 1;
+function getAutoIncrementId() {
+  return id++;
+}
+function getLocalAutoIncrementIdGenerator({
+  prefix,
+  suffix
+}) {
+  let localId = 1;
+  return () => {
+    return `${prefix || ""}${localId++}${suffix || ""}`;
+  };
+}
+export {
+  getAutoIncrementId,
+  getLocalAutoIncrementIdGenerator
+};