@ls-stack/utils 3.40.0 → 3.41.0

package/dist/{chunk-ADM37GSC.js → chunk-7L4KCZJJ.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-IATIXMCE.js";
 import {
   truncateString
-} from "./chunk-KW55OTUG.js";
+} from "./chunk-B3KFV2MH.js";
 import {
   isObject,
   isPlainObject
@@ -34,14 +34,12 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
       const entries = Object.entries(value).filter(
         ([, val]) => val !== void 0 || showUndefined
       );
-      const isSimpleObject = entries.every(
-        ([, val]) => {
-          if (typeof val === "string") {
-            return !val.includes("'") && !val.includes('"') && !val.includes("\\");
-          }
-          return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
+      const isSimpleObject = entries.every(([, val]) => {
+        if (typeof val === "string") {
+          return !val.includes("'") && !val.includes('"') && !val.includes("\\");
         }
-      );
+        return typeof val === "number" || typeof val === "boolean" || val === null || val === void 0;
+      });
       const shouldCollapse = isArrayItem ? entries.length > 1 : entries.length > 0;
       if (isSimpleObject && shouldCollapse) {
         let line = "{ ";
@@ -94,7 +92,9 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
         false
       );
       const willBeCollapsed = isObject(objVal) && (Object.keys(objVal).length === 0 || collapseObjects && depth + 1 > 0 && (() => {
-        const filteredEntries = Object.entries(objVal).filter(([, val]) => val !== void 0 || showUndefined);
+        const filteredEntries = Object.entries(objVal).filter(
+          ([, val]) => val !== void 0 || showUndefined
+        );
         const shouldCollapseThis = isArrayItem ? filteredEntries.length > 1 : filteredEntries.length > 0;
         return shouldCollapseThis && filteredEntries.every(([, val]) => {
           if (typeof val === "string") {
@@ -104,7 +104,9 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
         });
       })());
       const prevWasCollapsed = prevValue && isObject(prevValue) && (Object.keys(prevValue).length === 0 || collapseObjects && depth + 1 > 0 && (() => {
-        const filteredEntries = Object.entries(prevValue).filter(([, val]) => val !== void 0 || showUndefined);
+        const filteredEntries = Object.entries(prevValue).filter(
+          ([, val]) => val !== void 0 || showUndefined
+        );
         const shouldCollapseThis = isArrayItem ? filteredEntries.length > 1 : filteredEntries.length > 0;
         return shouldCollapseThis && filteredEntries.every(([, val]) => {
           if (typeof val === "string") {

package/dist/{chunk-KW55OTUG.js → chunk-B3KFV2MH.js}

@@ -33,10 +33,10 @@ function convertToCamelCase(str) {
   return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
 }
 function convertToSentenceCase(str) {
-  return str.split(/[\s_-]+/).map((word) => word.toLowerCase()).join(" ").replace(/^\w/, (char) => char.toUpperCase());
+  return str.replace(/[\s\-.]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).map((word) => word.toLowerCase()).join(" ").replace(/^\w/, (char) => char.toUpperCase());
 }
 function convertToTitleCase(str) {
-  return str.split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+  return str.replace(/[\s\-.]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
 }
 function truncateString(str, length, ellipsis = "\u2026") {
   if (str.length <= length) return str;

package/dist/chunk-DTE2QMWE.js

@@ -0,0 +1,48 @@
+// src/typingFnUtils.ts
+function asNonPartial(obj) {
+  return obj;
+}
+function typedObjectEntries(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;
+}
+
+export {
+  asNonPartial,
+  typedObjectEntries,
+  typedObjectKeys,
+  asType,
+  narrowStringToUnion,
+  typeOnRightExtendsLeftType,
+  isSubTypeOf,
+  isObjKey,
+  unionsAreTheSame,
+  asPartialUndefinedValues
+};

package/dist/concurrentCalls.d.cts

@@ -58,7 +58,8 @@ declare class ConcurrentCalls<R = unknown, E extends ResultValidErrors = Error>
     }>;
 }
 /**
- * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
+ * Executes multiple asynchronous calls concurrently and collects the results in
+ * a easier to use format.
  *
  * @template R - The type of the result value.
  */
@@ -88,7 +89,8 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
     }>;
 }
 /**
- * Executes multiple asynchronous calls concurrently with metadata for each call and collects the results in a easier to use format.
+ * Executes multiple asynchronous calls concurrently with metadata for each call
+ * and collects the results in a easier to use format.
  *
  * @template M - The type of the call metadata.
  * @template R - The type of the result value.
@@ -97,13 +99,15 @@ declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknow
 type ValueFromResult<R> = R extends Result<infer T, any> ? T : never;
 type ErrorFromResult<R> = R extends Result<any, infer E> ? E : never;
 /**
- * Executes multiple asynchronous result calls concurrently and collects the results in a easier to use format.
+ * Executes multiple asynchronous result calls concurrently and collects the
+ * results in a easier to use format.
  *
  * @template R - The type of the result function that will be called.
  */
 declare function concurrentResultCalls<ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCalls<ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
 /**
- * Executes multiple asynchronous result calls concurrently with metadata for each call and collects the results in a easier to use format.
+ * Executes multiple asynchronous result calls concurrently with metadata for
+ * each call and collects the results in a easier to use format.
  *
  * @template ResultFn - The type of the result function that will be called.
  */

package/dist/concurrentCalls.d.ts

@@ -58,7 +58,8 @@ declare class ConcurrentCalls<R = unknown, E extends ResultValidErrors = Error>
     }>;
 }
 /**
- * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
+ * Executes multiple asynchronous calls concurrently and collects the results in
+ * a easier to use format.
  *
  * @template R - The type of the result value.
  */
@@ -88,7 +89,8 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
     }>;
 }
 /**
- * Executes multiple asynchronous calls concurrently with metadata for each call and collects the results in a easier to use format.
+ * Executes multiple asynchronous calls concurrently with metadata for each call
+ * and collects the results in a easier to use format.
  *
  * @template M - The type of the call metadata.
  * @template R - The type of the result value.
@@ -97,13 +99,15 @@ declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknow
 type ValueFromResult<R> = R extends Result<infer T, any> ? T : never;
 type ErrorFromResult<R> = R extends Result<any, infer E> ? E : never;
 /**
- * Executes multiple asynchronous result calls concurrently and collects the results in a easier to use format.
+ * Executes multiple asynchronous result calls concurrently and collects the
+ * results in a easier to use format.
  *
  * @template R - The type of the result function that will be called.
  */
 declare function concurrentResultCalls<ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCalls<ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
 /**
- * Executes multiple asynchronous result calls concurrently with metadata for each call and collects the results in a easier to use format.
+ * Executes multiple asynchronous result calls concurrently with metadata for
+ * each call and collects the results in a easier to use format.
  *
  * @template ResultFn - The type of the result function that will be called.
  */

package/dist/concurrentCalls.js

@@ -1,6 +1,6 @@
 import {
   truncateString
-} from "./chunk-KW55OTUG.js";
+} from "./chunk-B3KFV2MH.js";
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";

package/dist/debounce.d.cts

@@ -1,38 +1,30 @@
 type DebounceOptions = {
-    /**
-     * @see _.leading
-     */
+    /** @see _.leading */
     leading?: boolean;
-    /**
-     * @see _.maxWait
-     */
+    /** @see _.maxWait */
     maxWait?: number;
-    /**
-     * @see _.trailing
-     */
+    /** @see _.trailing */
     trailing?: boolean;
 };
 interface DebouncedFunc<T extends (...args: any[]) => void> {
     /**
      * Call the original function, but applying the debounce rules.
      *
-     * If the debounced function can be run immediately, this calls it and returns its return
-     * value.
+     * If the debounced function can be run immediately, this calls it and returns
+     * its return value.
      *
-     * Otherwise, it returns the return value of the last invocation, or undefined if the debounced
-     * function was not invoked yet.
+     * Otherwise, it returns the return value of the last invocation, or undefined
+     * if the debounced function was not invoked yet.
      */
     (...args: Parameters<T>): ReturnType<T> | undefined;
-    /**
-     * Throw away any pending invocation of the debounced function.
-     */
+    /** Throw away any pending invocation of the debounced function. */
     cancel: () => void;
     /**
-     * If there is a pending invocation of the debounced function, invoke it immediately and return
-     * its return value.
+     * If there is a pending invocation of the debounced function, invoke it
+     * immediately and return its return value.
      *
-     * Otherwise, return the value from the last invocation, or undefined if the debounced function
-     * was never invoked.
+     * Otherwise, return the value from the last invocation, or undefined if the
+     * debounced function was never invoked.
      */
     flush: () => ReturnType<T> | undefined;
 }

package/dist/debounce.d.ts

@@ -1,38 +1,30 @@
 type DebounceOptions = {
-    /**
-     * @see _.leading
-     */
+    /** @see _.leading */
     leading?: boolean;
-    /**
-     * @see _.maxWait
-     */
+    /** @see _.maxWait */
     maxWait?: number;
-    /**
-     * @see _.trailing
-     */
+    /** @see _.trailing */
     trailing?: boolean;
 };
 interface DebouncedFunc<T extends (...args: any[]) => void> {
     /**
      * Call the original function, but applying the debounce rules.
      *
-     * If the debounced function can be run immediately, this calls it and returns its return
-     * value.
+     * If the debounced function can be run immediately, this calls it and returns
+     * its return value.
      *
-     * Otherwise, it returns the return value of the last invocation, or undefined if the debounced
-     * function was not invoked yet.
+     * Otherwise, it returns the return value of the last invocation, or undefined
+     * if the debounced function was not invoked yet.
      */
     (...args: Parameters<T>): ReturnType<T> | undefined;
-    /**
-     * Throw away any pending invocation of the debounced function.
-     */
+    /** Throw away any pending invocation of the debounced function. */
     cancel: () => void;
     /**
-     * If there is a pending invocation of the debounced function, invoke it immediately and return
-     * its return value.
+     * If there is a pending invocation of the debounced function, invoke it
+     * immediately and return its return value.
      *
-     * Otherwise, return the value from the last invocation, or undefined if the debounced function
-     * was never invoked.
+     * Otherwise, return the value from the last invocation, or undefined if the
+     * debounced function was never invoked.
      */
     flush: () => ReturnType<T> | undefined;
 }

package/dist/dedent.d.cts

@@ -1,72 +1,72 @@
-/**
- * Configuration options for the dedent function behavior
- */
+/** 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
+     * 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
+     * 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
+     * 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
+ * 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
-     */
+    /** Process a plain string to remove common indentation */
     (literals: string): string;
     /**
-     * Process a template literal to remove common indentation while handling interpolations
+     * Process a template literal to remove common indentation while handling
+     * interpolations
      */
     (strings: TemplateStringsArray, ...values: InterpolationValue[]): string;
-    /**
-     * Create a new dedent function with custom options
-     */
+    /** Create a new dedent function with custom options */
     withOptions: CreateDedent;
 }
-/**
- * Factory function type for creating dedent functions with custom options
- */
+/** 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.
+ * 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.
+ * 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`
+ *   ```typescript
+ *   const text = dedent`;
  *   function hello() {
  *     console.log('world');
  *   }
- * `;
- * // Result:
- * "function hello() {
- *   console.log('world');
- * }"
- * ```
+ *   `;
+ *   // Result:
+ *   "function hello() {
+ *     console.log('world');
+ *   }"
+ *   ```;
  */
 declare const dedent: Dedent;
 

package/dist/dedent.d.ts

@@ -1,72 +1,72 @@
-/**
- * Configuration options for the dedent function behavior
- */
+/** 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
+     * 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
+     * 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
+     * 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
+ * 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
-     */
+    /** Process a plain string to remove common indentation */
     (literals: string): string;
     /**
-     * Process a template literal to remove common indentation while handling interpolations
+     * Process a template literal to remove common indentation while handling
+     * interpolations
      */
     (strings: TemplateStringsArray, ...values: InterpolationValue[]): string;
-    /**
-     * Create a new dedent function with custom options
-     */
+    /** Create a new dedent function with custom options */
     withOptions: CreateDedent;
 }
-/**
- * Factory function type for creating dedent functions with custom options
- */
+/** 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.
+ * 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.
+ * 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`
+ *   ```typescript
+ *   const text = dedent`;
  *   function hello() {
  *     console.log('world');
  *   }
- * `;
- * // Result:
- * "function hello() {
- *   console.log('world');
- * }"
- * ```
+ *   `;
+ *   // Result:
+ *   "function hello() {
+ *     console.log('world');
+ *   }"
+ *   ```;
  */
 declare const dedent: Dedent;
 

package/dist/deepEqual.d.cts

@@ -1,18 +1,19 @@
 /**
  * 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
- *
- * @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
- * ```
  */
 declare function deepEqual(foo: any, bar: any, maxDepth?: number): boolean;
 declare function deepEqualWithMaxDepth(maxDepth: number): (foo: any, bar: any) => boolean;

package/dist/deepEqual.d.ts

@@ -1,18 +1,19 @@
 /**
  * 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
- *
- * @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
- * ```
  */
 declare function deepEqual(foo: any, bar: any, maxDepth?: number): boolean;
 declare function deepEqualWithMaxDepth(maxDepth: number): (foo: any, bar: any) => boolean;