@ls-stack/utils 3.30.1 → 3.32.0

package/lib/chunk-3LZQMZAS.js

@@ -0,0 +1,57 @@
+// src/stringUtils.ts
+function concatStrings(...args) {
+  const strings = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (Array.isArray(arg)) {
+      strings.push(concatStrings(...arg));
+      continue;
+    }
+    strings.push(arg);
+  }
+  return strings.join("");
+}
+var joinStrings = concatStrings;
+function formatNum(num, maxDecimalsOrOptions = 2) {
+  const options = typeof maxDecimalsOrOptions === "number" ? {
+    maximumFractionDigits: maxDecimalsOrOptions
+  } : maxDecimalsOrOptions;
+  return num.toLocaleString("en-US", options);
+}
+function isSnakeCase(str) {
+  return /^[a-z0-9_]+$/.test(str);
+}
+function convertToSnakeCase(str) {
+  return str.replace(/[\s\-.]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9_]/g, "").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+}
+function convertToPascalCase(str) {
+  return str.split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function convertToCamelCase(str) {
+  const pascalCase = convertToPascalCase(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());
+}
+function convertToTitleCase(str) {
+  return str.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;
+  return str.slice(0, length - 1) + ellipsis;
+}
+
+export {
+  concatStrings,
+  joinStrings,
+  formatNum,
+  isSnakeCase,
+  convertToSnakeCase,
+  convertToPascalCase,
+  convertToCamelCase,
+  convertToSentenceCase,
+  convertToTitleCase,
+  truncateString
+};

package/lib/{chunk-QLD7KG5I.js → chunk-IY3KYH32.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-IATIXMCE.js";
 import {
   truncateString
-} from "./chunk-4REIIZQY.js";
+} from "./chunk-3LZQMZAS.js";
 import {
   isObject,
   isPlainObject

package/lib/concurrentCalls.cjs

@@ -23,7 +23,9 @@ __export(concurrentCalls_exports, {
   ConcurrentCallsAggregateError: () => ConcurrentCallsAggregateError,
   ConcurrentCallsWithMetadataAggregateError: () => ConcurrentCallsWithMetadataAggregateError,
   concurrentCalls: () => concurrentCalls,
-  concurrentCallsWithMetadata: () => concurrentCallsWithMetadata
+  concurrentCallsWithMetadata: () => concurrentCallsWithMetadata,
+  concurrentResultCalls: () => concurrentResultCalls,
+  concurrentResultsWithMetadata: () => concurrentResultsWithMetadata
 });
 module.exports = __toCommonJS(concurrentCalls_exports);
 var import_t_result = require("t-result");
@@ -60,6 +62,15 @@ function truncateArray(array, maxLength, appendIfTruncated) {
   return result;
 }
 
+// src/safeJson.ts
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return void 0;
+  }
+}
+
 // src/sleep.ts
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -93,7 +104,10 @@ var ConcurrentCallsAggregateError = class extends AggregateError {
   failed = 0;
   constructor(errors, total, failed) {
     const messages = errors.map(
-      (error) => `- ${truncateString(error.message, 100)}`
+      (error) => `- ${truncateString(
+        error instanceof Error ? error.message : safeJsonStringify(error) ?? "???",
+        100
+      )}`
     );
     const message = formatErrorMessagesWithCounts(messages, failed, total);
     super(errors, message);
@@ -122,7 +136,10 @@ var ConcurrentCallsWithMetadataAggregateError = class extends AggregateError {
         }
       } catch (_) {
       }
-      return `- ${metadataPrefix}${truncateString(error.message, 100)}`;
+      return `- ${metadataPrefix}${truncateString(
+        error instanceof Error ? error.message : safeJsonStringify(error) ?? "???",
+        100
+      )}`;
     });
     const message = formatErrorMessagesWithCounts(messages, failed, total);
     const errorInstances = errors.map((e) => e.error);
@@ -136,11 +153,20 @@ var ConcurrentCallsWithMetadataAggregateError = class extends AggregateError {
 var ConcurrentCalls = class {
   #pendingCalls = [];
   #alreadyRun = false;
+  allowResultify = true;
+  constructor(allowResultify) {
+    this.allowResultify = allowResultify;
+  }
   add(...calls) {
     this.#pendingCalls.push(...calls);
     return this;
   }
   resultifyAdd(...calls) {
+    if (!this.allowResultify) {
+      throw new Error(
+        "resultifyAdd is not allowed when using concurrentResults"
+      );
+    }
     const processedCalls = calls.map((call) => {
       return async () => {
         try {
@@ -221,11 +247,15 @@ var ConcurrentCalls = class {
   }
 };
 function concurrentCalls() {
-  return new ConcurrentCalls();
+  return new ConcurrentCalls(true);
 }
 var ConcurrentCallsWithMetadata = class {
   #pendingCalls = [];
   #alreadyRun = false;
+  allowResultify = true;
+  constructor(allowResultify) {
+    this.allowResultify = allowResultify;
+  }
   add(...calls) {
     invariant(
       !this.#alreadyRun,
@@ -235,6 +265,11 @@ var ConcurrentCallsWithMetadata = class {
     return this;
   }
   resultifyAdd(...items) {
+    if (!this.allowResultify) {
+      throw new Error(
+        "resultifyAdd is not allowed when using concurrentResultsWithMetadata"
+      );
+    }
     const processedItems = items.map(({ fn, metadata }) => {
       const cb = () => (0, import_t_result.resultify)(async () => {
         const valueOrPromise = fn();
@@ -352,12 +387,20 @@ var ConcurrentCallsWithMetadata = class {
   }
 };
 function concurrentCallsWithMetadata() {
-  return new ConcurrentCallsWithMetadata();
+  return new ConcurrentCallsWithMetadata(true);
+}
+function concurrentResultCalls() {
+  return new ConcurrentCalls(false);
+}
+function concurrentResultsWithMetadata() {
+  return new ConcurrentCallsWithMetadata(false);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConcurrentCallsAggregateError,
   ConcurrentCallsWithMetadataAggregateError,
   concurrentCalls,
-  concurrentCallsWithMetadata
+  concurrentCallsWithMetadata,
+  concurrentResultCalls,
+  concurrentResultsWithMetadata
 });

package/lib/concurrentCalls.d.cts

@@ -1,21 +1,21 @@
-import { Result } from 't-result';
+import { ResultValidErrors, Result } from 't-result';
 
 declare class ConcurrentCallsAggregateError extends AggregateError {
-    errors: Error[];
+    errors: ResultValidErrors[];
     total: number;
     failed: number;
-    constructor(errors: Error[], total: number, failed: number);
+    constructor(errors: ResultValidErrors[], total: number, failed: number);
 }
 declare class ConcurrentCallsWithMetadataAggregateError<M extends ValidMetadata> extends AggregateError {
-    errors: Error[];
+    errors: ResultValidErrors[];
     errorsWithMetadata: {
-        error: Error;
+        error: ResultValidErrors;
         metadata: M;
     }[];
     total: number;
     failed: number;
     constructor(errors: {
-        error: Error;
+        error: ResultValidErrors;
         metadata: M;
     }[], total: number, failed: number);
 }
@@ -27,12 +27,12 @@ type SucceededCall<R, M> = {
     value: R;
     metadata: M;
 };
-type FailedCall<M, E extends Error = Error> = {
+type FailedCall<M, E extends ResultValidErrors = Error> = {
     metadata: M;
     error: E;
 };
-type Action<R, E extends Error> = () => Promise<Result<R, E>>;
-type SettledResultWithMetadata<R, M, E extends Error = Error> = {
+type Action<R, E extends ResultValidErrors> = () => Promise<Result<R, E>>;
+type SettledResultWithMetadata<R, M, E extends ResultValidErrors = Error> = {
     ok: true;
     value: R;
     metadata: M;
@@ -42,8 +42,10 @@ type SettledResultWithMetadata<R, M, E extends Error = Error> = {
     error: E;
     metadata: M;
 };
-declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
+declare class ConcurrentCalls<R = unknown, E extends ResultValidErrors = Error> {
     #private;
+    allowResultify: boolean;
+    constructor(allowResultify: boolean);
     add(...calls: Action<R, E>[]): this;
     resultifyAdd(...calls: ((() => R) | (() => Promise<R>))[]): this;
     runAll({ delayStart }?: RunProps): Promise<Result<R[], E>>;
@@ -59,11 +61,12 @@ declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
  * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
  *
  * @template R - The type of the result value.
- * @template E - The type of the error.
  */
 declare function concurrentCalls<R = unknown>(): ConcurrentCalls<R, Error>;
-declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends Error = Error> {
+declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends ResultValidErrors = Error> {
     #private;
+    allowResultify: boolean;
+    constructor(allowResultify: boolean);
     add(...calls: {
         fn: Action<R, E>;
         metadata: M;
@@ -85,12 +88,25 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
     }>;
 }
 /**
- * Executes multiple asynchronous calls concurrently 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.
- * @template E - The type of the error from individual Result objects.
  */
 declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknown>(): ConcurrentCallsWithMetadata<M, R, Error>;
+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.
+ *
+ * @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.
+ *
+ * @template ResultFn - The type of the result function that will be called.
+ */
+declare function concurrentResultsWithMetadata<M extends ValidMetadata, ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCallsWithMetadata<M, ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
 
-export { ConcurrentCallsAggregateError, ConcurrentCallsWithMetadataAggregateError, concurrentCalls, concurrentCallsWithMetadata };
+export { ConcurrentCallsAggregateError, ConcurrentCallsWithMetadataAggregateError, concurrentCalls, concurrentCallsWithMetadata, concurrentResultCalls, concurrentResultsWithMetadata };

package/lib/concurrentCalls.d.ts

@@ -1,21 +1,21 @@
-import { Result } from 't-result';
+import { ResultValidErrors, Result } from 't-result';
 
 declare class ConcurrentCallsAggregateError extends AggregateError {
-    errors: Error[];
+    errors: ResultValidErrors[];
     total: number;
     failed: number;
-    constructor(errors: Error[], total: number, failed: number);
+    constructor(errors: ResultValidErrors[], total: number, failed: number);
 }
 declare class ConcurrentCallsWithMetadataAggregateError<M extends ValidMetadata> extends AggregateError {
-    errors: Error[];
+    errors: ResultValidErrors[];
     errorsWithMetadata: {
-        error: Error;
+        error: ResultValidErrors;
         metadata: M;
     }[];
     total: number;
     failed: number;
     constructor(errors: {
-        error: Error;
+        error: ResultValidErrors;
         metadata: M;
     }[], total: number, failed: number);
 }
@@ -27,12 +27,12 @@ type SucceededCall<R, M> = {
     value: R;
     metadata: M;
 };
-type FailedCall<M, E extends Error = Error> = {
+type FailedCall<M, E extends ResultValidErrors = Error> = {
     metadata: M;
     error: E;
 };
-type Action<R, E extends Error> = () => Promise<Result<R, E>>;
-type SettledResultWithMetadata<R, M, E extends Error = Error> = {
+type Action<R, E extends ResultValidErrors> = () => Promise<Result<R, E>>;
+type SettledResultWithMetadata<R, M, E extends ResultValidErrors = Error> = {
     ok: true;
     value: R;
     metadata: M;
@@ -42,8 +42,10 @@ type SettledResultWithMetadata<R, M, E extends Error = Error> = {
     error: E;
     metadata: M;
 };
-declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
+declare class ConcurrentCalls<R = unknown, E extends ResultValidErrors = Error> {
     #private;
+    allowResultify: boolean;
+    constructor(allowResultify: boolean);
     add(...calls: Action<R, E>[]): this;
     resultifyAdd(...calls: ((() => R) | (() => Promise<R>))[]): this;
     runAll({ delayStart }?: RunProps): Promise<Result<R[], E>>;
@@ -59,11 +61,12 @@ declare class ConcurrentCalls<R = unknown, E extends Error = Error> {
  * Executes multiple asynchronous calls concurrently and collects the results in a easier to use format.
  *
  * @template R - The type of the result value.
- * @template E - The type of the error.
  */
 declare function concurrentCalls<R = unknown>(): ConcurrentCalls<R, Error>;
-declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends Error = Error> {
+declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown, E extends ResultValidErrors = Error> {
     #private;
+    allowResultify: boolean;
+    constructor(allowResultify: boolean);
     add(...calls: {
         fn: Action<R, E>;
         metadata: M;
@@ -85,12 +88,25 @@ declare class ConcurrentCallsWithMetadata<M extends ValidMetadata, R = unknown,
     }>;
 }
 /**
- * Executes multiple asynchronous calls concurrently 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.
- * @template E - The type of the error from individual Result objects.
  */
 declare function concurrentCallsWithMetadata<M extends ValidMetadata, R = unknown>(): ConcurrentCallsWithMetadata<M, R, Error>;
+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.
+ *
+ * @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.
+ *
+ * @template ResultFn - The type of the result function that will be called.
+ */
+declare function concurrentResultsWithMetadata<M extends ValidMetadata, ResultFn extends (...args: any[]) => Promise<Result<unknown, ResultValidErrors>>>(): ConcurrentCallsWithMetadata<M, ValueFromResult<Awaited<ReturnType<ResultFn>>>, ErrorFromResult<Awaited<ReturnType<ResultFn>>>>;
 
-export { ConcurrentCallsAggregateError, ConcurrentCallsWithMetadataAggregateError, concurrentCalls, concurrentCallsWithMetadata };
+export { ConcurrentCallsAggregateError, ConcurrentCallsWithMetadataAggregateError, concurrentCalls, concurrentCallsWithMetadata, concurrentResultCalls, concurrentResultsWithMetadata };

package/lib/concurrentCalls.js

@@ -1,9 +1,12 @@
 import {
   truncateString
-} from "./chunk-4REIIZQY.js";
+} from "./chunk-3LZQMZAS.js";
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";
+import {
+  safeJsonStringify
+} from "./chunk-VAAMRG4K.js";
 import {
   truncateArray
 } from "./chunk-SRVMMYSW.js";
@@ -16,7 +19,11 @@ import {
 } from "./chunk-JF2MDHOJ.js";
 
 // src/concurrentCalls.ts
-import { Result, resultify, unknownToError } from "t-result";
+import {
+  Result,
+  resultify,
+  unknownToError
+} from "t-result";
 function formatErrorMessagesWithCounts(messages, failed, total) {
   const errorMessageCounts = /* @__PURE__ */ new Map();
   for (const message of messages) {
@@ -38,7 +45,10 @@ var ConcurrentCallsAggregateError = class extends AggregateError {
   failed = 0;
   constructor(errors, total, failed) {
     const messages = errors.map(
-      (error) => `- ${truncateString(error.message, 100)}`
+      (error) => `- ${truncateString(
+        error instanceof Error ? error.message : safeJsonStringify(error) ?? "???",
+        100
+      )}`
     );
     const message = formatErrorMessagesWithCounts(messages, failed, total);
     super(errors, message);
@@ -67,7 +77,10 @@ var ConcurrentCallsWithMetadataAggregateError = class extends AggregateError {
         }
       } catch (_) {
       }
-      return `- ${metadataPrefix}${truncateString(error.message, 100)}`;
+      return `- ${metadataPrefix}${truncateString(
+        error instanceof Error ? error.message : safeJsonStringify(error) ?? "???",
+        100
+      )}`;
     });
     const message = formatErrorMessagesWithCounts(messages, failed, total);
     const errorInstances = errors.map((e) => e.error);
@@ -81,11 +94,20 @@ var ConcurrentCallsWithMetadataAggregateError = class extends AggregateError {
 var ConcurrentCalls = class {
   #pendingCalls = [];
   #alreadyRun = false;
+  allowResultify = true;
+  constructor(allowResultify) {
+    this.allowResultify = allowResultify;
+  }
   add(...calls) {
     this.#pendingCalls.push(...calls);
     return this;
   }
   resultifyAdd(...calls) {
+    if (!this.allowResultify) {
+      throw new Error(
+        "resultifyAdd is not allowed when using concurrentResults"
+      );
+    }
     const processedCalls = calls.map((call) => {
       return async () => {
         try {
@@ -166,11 +188,15 @@ var ConcurrentCalls = class {
   }
 };
 function concurrentCalls() {
-  return new ConcurrentCalls();
+  return new ConcurrentCalls(true);
 }
 var ConcurrentCallsWithMetadata = class {
   #pendingCalls = [];
   #alreadyRun = false;
+  allowResultify = true;
+  constructor(allowResultify) {
+    this.allowResultify = allowResultify;
+  }
   add(...calls) {
     invariant(
       !this.#alreadyRun,
@@ -180,6 +206,11 @@ var ConcurrentCallsWithMetadata = class {
     return this;
   }
   resultifyAdd(...items) {
+    if (!this.allowResultify) {
+      throw new Error(
+        "resultifyAdd is not allowed when using concurrentResultsWithMetadata"
+      );
+    }
     const processedItems = items.map(({ fn, metadata }) => {
       const cb = () => resultify(async () => {
         const valueOrPromise = fn();
@@ -297,11 +328,19 @@ var ConcurrentCallsWithMetadata = class {
   }
 };
 function concurrentCallsWithMetadata() {
-  return new ConcurrentCallsWithMetadata();
+  return new ConcurrentCallsWithMetadata(true);
+}
+function concurrentResultCalls() {
+  return new ConcurrentCalls(false);
+}
+function concurrentResultsWithMetadata() {
+  return new ConcurrentCallsWithMetadata(false);
 }
 export {
   ConcurrentCallsAggregateError,
   ConcurrentCallsWithMetadataAggregateError,
   concurrentCalls,
-  concurrentCallsWithMetadata
+  concurrentCallsWithMetadata,
+  concurrentResultCalls,
+  concurrentResultsWithMetadata
 };

package/lib/stringUtils.cjs

@@ -21,7 +21,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var stringUtils_exports = {};
 __export(stringUtils_exports, {
   concatStrings: () => concatStrings,
+  convertToCamelCase: () => convertToCamelCase,
+  convertToPascalCase: () => convertToPascalCase,
+  convertToSentenceCase: () => convertToSentenceCase,
   convertToSnakeCase: () => convertToSnakeCase,
+  convertToTitleCase: () => convertToTitleCase,
   formatNum: () => formatNum,
   isSnakeCase: () => isSnakeCase,
   joinStrings: () => joinStrings,
@@ -42,17 +46,30 @@ function concatStrings(...args) {
   return strings.join("");
 }
 var joinStrings = concatStrings;
-function formatNum(num) {
-  return num.toLocaleString("en-US", {
-    minimumFractionDigits: 2,
-    maximumFractionDigits: 2
-  });
+function formatNum(num, maxDecimalsOrOptions = 2) {
+  const options = typeof maxDecimalsOrOptions === "number" ? {
+    maximumFractionDigits: maxDecimalsOrOptions
+  } : maxDecimalsOrOptions;
+  return num.toLocaleString("en-US", options);
 }
 function isSnakeCase(str) {
   return /^[a-z0-9_]+$/.test(str);
 }
 function convertToSnakeCase(str) {
-  return str.replace(/([A-Z])/g, "_$1").replace(/[^a-z0-9_]/g, "").toLowerCase();
+  return str.replace(/[\s\-.]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9_]/g, "").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+}
+function convertToPascalCase(str) {
+  return str.split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function convertToCamelCase(str) {
+  const pascalCase = convertToPascalCase(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());
+}
+function convertToTitleCase(str) {
+  return str.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;
@@ -61,7 +78,11 @@ function truncateString(str, length, ellipsis = "\u2026") {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   concatStrings,
+  convertToCamelCase,
+  convertToPascalCase,
+  convertToSentenceCase,
   convertToSnakeCase,
+  convertToTitleCase,
   formatNum,
   isSnakeCase,
   joinStrings,

package/lib/stringUtils.d.cts

@@ -13,9 +13,13 @@ declare function concatStrings(...args: (Arg | Arg[])[]): string;
  * @deprecated Use {@link concatStrings} instead
  */
 declare const joinStrings: typeof concatStrings;
-declare function formatNum(num: number): string;
+declare function formatNum(num: number, maxDecimalsOrOptions?: number | Intl.NumberFormatOptions): string;
 declare function isSnakeCase(str: string): boolean;
 declare function convertToSnakeCase(str: string): string;
+declare function convertToPascalCase(str: string): string;
+declare function convertToCamelCase(str: string): string;
+declare function convertToSentenceCase(str: string): string;
+declare function convertToTitleCase(str: string): string;
 declare function truncateString(str: string, length: number, ellipsis?: string): string;
 
-export { concatStrings, convertToSnakeCase, formatNum, isSnakeCase, joinStrings, truncateString };
+export { concatStrings, convertToCamelCase, convertToPascalCase, convertToSentenceCase, convertToSnakeCase, convertToTitleCase, formatNum, isSnakeCase, joinStrings, truncateString };

package/lib/stringUtils.d.ts

@@ -13,9 +13,13 @@ declare function concatStrings(...args: (Arg | Arg[])[]): string;
  * @deprecated Use {@link concatStrings} instead
  */
 declare const joinStrings: typeof concatStrings;
-declare function formatNum(num: number): string;
+declare function formatNum(num: number, maxDecimalsOrOptions?: number | Intl.NumberFormatOptions): string;
 declare function isSnakeCase(str: string): boolean;
 declare function convertToSnakeCase(str: string): string;
+declare function convertToPascalCase(str: string): string;
+declare function convertToCamelCase(str: string): string;
+declare function convertToSentenceCase(str: string): string;
+declare function convertToTitleCase(str: string): string;
 declare function truncateString(str: string, length: number, ellipsis?: string): string;
 
-export { concatStrings, convertToSnakeCase, formatNum, isSnakeCase, joinStrings, truncateString };
+export { concatStrings, convertToCamelCase, convertToPascalCase, convertToSentenceCase, convertToSnakeCase, convertToTitleCase, formatNum, isSnakeCase, joinStrings, truncateString };

package/lib/stringUtils.js

@@ -1,14 +1,22 @@
 import {
   concatStrings,
+  convertToCamelCase,
+  convertToPascalCase,
+  convertToSentenceCase,
   convertToSnakeCase,
+  convertToTitleCase,
   formatNum,
   isSnakeCase,
   joinStrings,
   truncateString
-} from "./chunk-4REIIZQY.js";
+} from "./chunk-3LZQMZAS.js";
 export {
   concatStrings,
+  convertToCamelCase,
+  convertToPascalCase,
+  convertToSentenceCase,
   convertToSnakeCase,
+  convertToTitleCase,
   formatNum,
   isSnakeCase,
   joinStrings,

package/lib/testUtils.js

@@ -1,6 +1,6 @@
 import {
   yamlStringify
-} from "./chunk-QLD7KG5I.js";
+} from "./chunk-IY3KYH32.js";
 import {
   omit,
   pick
@@ -18,7 +18,7 @@ import {
 import {
   clampMin
 } from "./chunk-HTCYUMDR.js";
-import "./chunk-4REIIZQY.js";
+import "./chunk-3LZQMZAS.js";
 import {
   arrayWithPrevAndIndex,
   filterAndMap

package/lib/yamlStringify.js

@@ -1,8 +1,8 @@
 import {
   yamlStringify
-} from "./chunk-QLD7KG5I.js";
+} from "./chunk-IY3KYH32.js";
 import "./chunk-IATIXMCE.js";
-import "./chunk-4REIIZQY.js";
+import "./chunk-3LZQMZAS.js";
 import "./chunk-JF2MDHOJ.js";
 export {
   yamlStringify

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.30.1",
+  "version": "3.32.0",
   "license": "MIT",
   "files": [
     "lib",