@cognite/underscore 1.0.1 → 1.48535.0

package/dist/retry-async.d.ts

@@ -1,92 +1,92 @@
 /**
- * Retries an operation a configurable number of times.
- *
- * The flow is as follows:
- * 1. Call the `operation` function.
- * 2. If it resolves, return the resolved value.
- * 3. If it throws an error, check if we should retry (based on `maxAttempts` and `shouldRetry`).
- * 4. If we should retry, calculate the delay using `delayInMsCalculator`, call `onAttemptFail`, wait for that duration, and then repeat from step 1.
- * 5. If we shouldn't retry (either because we've exhausted attempts or `shouldRetry` returned false), re-throw the error.
- *
- * By default, we use exponential backoff with jitter for delays between attempts.
- *
- * @param operation The function to execute and retry.
- * @param config Configuration for the retry mechanism.
- * @returns A Promise that resolves with the result of the successful operation.
- * @throws Will throw if, and only if, all retry attempts failed. Only the last exception from `operation` will be re-thrown.
- *
- * @example
- * ```ts
- * // Basic usage: retry a function that may fail
- * await retryAsync(() => {
- *   if (Math.random() < 0.7) throw new Error('Transient error');
- *   return 'success';
- * });
- * ```
- *
- * * @example
- * ```ts
- * try {
- *   return retryAsync(() => fetchAllUsers());
- * } catch (err) {
- *   console.error('Failed to fetch users after several attempts:', err);
- *   notifyUser('Failed to fetch users. Please try again later.');
- * }
- * ```
- *
- * @example
- * ```ts
- * // Custom retry logic and delay
- * await retryAsync(
- *   async () => myFetch('https://api.example.com/data'),
- *   {
- *     maxAttempts: 10,
- *     shouldRetry: (error) => error instanceof NetworkError,
- *     delayInMsCalculator: (attempt) => 100 * attempt,
- *     onAttemptFail: (error, attempt, delay) => {
- *       console.warn(`Attempt ${attempt} failed (waiting ${delay}ms):`, error);
- *     },
- *   }
- * );
- * ```
- */
+* Retries an operation a configurable number of times.
+*
+* The flow is as follows:
+* 1. Call the `operation` function.
+* 2. If it resolves, return the resolved value.
+* 3. If it throws an error, check if we should retry (based on `maxAttempts` and `shouldRetry`).
+* 4. If we should retry, calculate the delay using `delayInMsCalculator`, call `onAttemptFail`, wait for that duration, and then repeat from step 1.
+* 5. If we shouldn't retry (either because we've exhausted attempts or `shouldRetry` returned false), re-throw the error.
+*
+* By default, we use exponential backoff with jitter for delays between attempts.
+*
+* @param operation The function to execute and retry.
+* @param config Configuration for the retry mechanism.
+* @returns A Promise that resolves with the result of the successful operation.
+* @throws Will throw if, and only if, all retry attempts failed. Only the last exception from `operation` will be re-thrown.
+*
+* @example
+* ```ts
+* // Basic usage: retry a function that may fail
+* await retryAsync(() => {
+*   if (Math.random() < 0.7) throw new Error('Transient error');
+*   return 'success';
+* });
+* ```
+*
+* * @example
+* ```ts
+* try {
+*   return retryAsync(() => fetchAllUsers());
+* } catch (err) {
+*   console.error('Failed to fetch users after several attempts:', err);
+*   notifyUser('Failed to fetch users. Please try again later.');
+* }
+* ```
+*
+* @example
+* ```ts
+* // Custom retry logic and delay
+* await retryAsync(
+*   async () => myFetch('https://api.example.com/data'),
+*   {
+*     maxAttempts: 10,
+*     shouldRetry: (error) => error instanceof NetworkError,
+*     delayInMsCalculator: (attempt) => 100 * attempt,
+*     onAttemptFail: (error, attempt, delay) => {
+*       console.warn(`Attempt ${attempt} failed (waiting ${delay}ms):`, error);
+*     },
+*   }
+* );
+* ```
+*/
 export declare function retryAsync<T>(operation: () => T | Promise<T>, options?: RetryAsyncOptions): Promise<T>;
 /**
- * Configuration options for {@link retryAsync}.
- */
+* Configuration options for {@link retryAsync}.
+*/
 export type RetryAsyncOptions = {
-    /**
-     * The maximum number of attempts to make, including the initial one.
-     * Must be in the range [1, 100].
-     * @default 5
-     */
-    maxAttempts?: number;
-    /**
-     * A function to determine if the thrown error should trigger a retry.
-     *
-     * If this function returns `true`, a retry will be performed (up to `maxAttempts`).
-     * If it returns `false`, the error will be immediately thrown and not retried.
-     * @default (error) => true // Retries on any error.
-     * @returns Whether to retry based on the provided error.
-     */
-    shouldRetry?: (error: unknown) => boolean;
-    /**
-     * An optional callback executed after a failed attempt, but before the next delay.
-     *
-     * Useful for logging or metrics.
-     * @param error The error that caused the failure.
-     * @param attempt The current failed attempt number (1, 2, 3, etc.).
-     * @param delayInMs The calculated delay before the next attempt.
-     */
-    onAttemptFail?: (error: unknown, attempt: number, delayInMs: number) => void;
-    /**
-     * The function that calculates the delay (in milliseconds) before the
-     * next attempt.
-     *
-     * It takes the current attempt number (starting at 1) and returns the delay.
-     * @default Delay calculated using the {@link exponentialBackoffWithJitter} function.
-     *
-     * @returns The delay in milliseconds before the next attempt.
-     */
-    delayInMsCalculator?: (attempt: number) => number;
+	/**
+	* The maximum number of attempts to make, including the initial one.
+	* Must be in the range [1, 100].
+	* @default 5
+	*/
+	maxAttempts?: number;
+	/**
+	* A function to determine if the thrown error should trigger a retry.
+	*
+	* If this function returns `true`, a retry will be performed (up to `maxAttempts`).
+	* If it returns `false`, the error will be immediately thrown and not retried.
+	* @default (error) => true // Retries on any error.
+	* @returns Whether to retry based on the provided error.
+	*/
+	shouldRetry?: (error: unknown) => boolean;
+	/**
+	* An optional callback executed after a failed attempt, but before the next delay.
+	*
+	* Useful for logging or metrics.
+	* @param error The error that caused the failure.
+	* @param attempt The current failed attempt number (1, 2, 3, etc.).
+	* @param delayInMs The calculated delay before the next attempt.
+	*/
+	onAttemptFail?: (error: unknown, attempt: number, delayInMs: number) => void;
+	/**
+	* The function that calculates the delay (in milliseconds) before the
+	* next attempt.
+	*
+	* It takes the current attempt number (starting at 1) and returns the delay.
+	* @default Delay calculated using the {@link exponentialBackoffWithJitter} function.
+	*
+	* @returns The delay in milliseconds before the next attempt.
+	*/
+	delayInMsCalculator?: (attempt: number) => number;
 };

package/dist/retry-async.js

@@ -1,18 +1,89 @@
-import { exponentialBackoffWithJitter as e } from "./exponential-backoff-with-jitter.js";
-import { sleep as t } from "./sleep.js";
-//#region libs/shared/underscore/src/retry-async.ts
-async function n(n, r = {}) {
-	let i = r.maxAttempts ?? 5, a = r.shouldRetry ?? (() => !0), o = r.onAttemptFail, s = r.delayInMsCalculator ?? e;
-	if (i < 1) throw Error("`maxAttempts` must be 1 or greater");
-	if (i > 100) throw Error("`maxAttempts` must be 100 or less");
-	let c = 1;
-	for (;;) try {
-		return await n();
-	} catch (e) {
-		if (c >= i || !a(e)) throw e;
-		let n = s(c);
-		o?.(e, c, n), await t(n), c++;
-	}
+import { exponentialBackoffWithJitter } from "./exponential-backoff-with-jitter.js";
+import { sleep } from "./sleep.js";
+/**
+ * Retries an operation a configurable number of times.
+ *
+ * The flow is as follows:
+ * 1. Call the `operation` function.
+ * 2. If it resolves, return the resolved value.
+ * 3. If it throws an error, check if we should retry (based on `maxAttempts` and `shouldRetry`).
+ * 4. If we should retry, calculate the delay using `delayInMsCalculator`, call `onAttemptFail`, wait for that duration, and then repeat from step 1.
+ * 5. If we shouldn't retry (either because we've exhausted attempts or `shouldRetry` returned false), re-throw the error.
+ *
+ * By default, we use exponential backoff with jitter for delays between attempts.
+ *
+ * @param operation The function to execute and retry.
+ * @param config Configuration for the retry mechanism.
+ * @returns A Promise that resolves with the result of the successful operation.
+ * @throws Will throw if, and only if, all retry attempts failed. Only the last exception from `operation` will be re-thrown.
+ *
+ * @example
+ * ```ts
+ * // Basic usage: retry a function that may fail
+ * await retryAsync(() => {
+ *   if (Math.random() < 0.7) throw new Error('Transient error');
+ *   return 'success';
+ * });
+ * ```
+ *
+ * * @example
+ * ```ts
+ * try {
+ *   return retryAsync(() => fetchAllUsers());
+ * } catch (err) {
+ *   console.error('Failed to fetch users after several attempts:', err);
+ *   notifyUser('Failed to fetch users. Please try again later.');
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Custom retry logic and delay
+ * await retryAsync(
+ *   async () => myFetch('https://api.example.com/data'),
+ *   {
+ *     maxAttempts: 10,
+ *     shouldRetry: (error) => error instanceof NetworkError,
+ *     delayInMsCalculator: (attempt) => 100 * attempt,
+ *     onAttemptFail: (error, attempt, delay) => {
+ *       console.warn(`Attempt ${attempt} failed (waiting ${delay}ms):`, error);
+ *     },
+ *   }
+ * );
+ * ```
+ */ export async function retryAsync(operation, options = {}) {
+    var _options_maxAttempts, _options_shouldRetry, _options_delayInMsCalculator;
+    let maxAttempts = (_options_maxAttempts = options.maxAttempts) !== null && _options_maxAttempts !== void 0 ? _options_maxAttempts : 5;
+    let shouldRetry = (_options_shouldRetry = options.shouldRetry) !== null && _options_shouldRetry !== void 0 ? _options_shouldRetry : ()=>true;
+    let onAttemptFail = options.onAttemptFail;
+    let delayInMsCalculator = (_options_delayInMsCalculator = options.delayInMsCalculator) !== null && _options_delayInMsCalculator !== void 0 ? _options_delayInMsCalculator : exponentialBackoffWithJitter;
+    if (maxAttempts < 1) {
+        throw new Error('`maxAttempts` must be 1 or greater');
+    }
+    if (maxAttempts > 100) {
+        throw new Error('`maxAttempts` must be 100 or less');
+    }
+    let attempts = 1;
+    // The "infinite" loop here is intentional, and it isn't "infinite" in practice.
+    // We have two exit paths for this loop (and one of them will occur eventually):
+    // 1. The operation succeeds and we return the result.
+    // 2. The operation fails and we exceed `maxAttempts` or `shouldRetry` returns `false`,
+    //    and we throw the error. As `maxAttempts` is finite, we will eventually exit here.
+    for(;;){
+        try {
+            // Exit path 1
+            return await operation();
+        } catch (error) {
+            if (attempts >= maxAttempts || !shouldRetry(error)) {
+                // Exit path 2
+                throw error;
+            }
+            const delayInMs = delayInMsCalculator(attempts);
+            onAttemptFail === null || onAttemptFail === void 0 ? void 0 : onAttemptFail(error, attempts, delayInMs);
+            await sleep(delayInMs);
+            attempts++;
+        }
+    }
 }
-//#endregion
-export { n as retryAsync };
+
+//# sourceMappingURL=retry-async.js.map

package/dist/retry-async.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/retry-async.ts"],"sourcesContent":["import { exponentialBackoffWithJitter } from './exponential-backoff-with-jitter';\nimport { sleep } from './sleep';\n\n/**\n * Retries an operation a configurable number of times.\n *\n * The flow is as follows:\n * 1. Call the `operation` function.\n * 2. If it resolves, return the resolved value.\n * 3. If it throws an error, check if we should retry (based on `maxAttempts` and `shouldRetry`).\n * 4. If we should retry, calculate the delay using `delayInMsCalculator`, call `onAttemptFail`, wait for that duration, and then repeat from step 1.\n * 5. If we shouldn't retry (either because we've exhausted attempts or `shouldRetry` returned false), re-throw the error.\n *\n * By default, we use exponential backoff with jitter for delays between attempts.\n *\n * @param operation The function to execute and retry.\n * @param config Configuration for the retry mechanism.\n * @returns A Promise that resolves with the result of the successful operation.\n * @throws Will throw if, and only if, all retry attempts failed. Only the last exception from `operation` will be re-thrown.\n *\n * @example\n * ```ts\n * // Basic usage: retry a function that may fail\n * await retryAsync(() => {\n *   if (Math.random() < 0.7) throw new Error('Transient error');\n *   return 'success';\n * });\n * ```\n *\n * * @example\n * ```ts\n * try {\n *   return retryAsync(() => fetchAllUsers());\n * } catch (err) {\n *   console.error('Failed to fetch users after several attempts:', err);\n *   notifyUser('Failed to fetch users. Please try again later.');\n * }\n * ```\n *\n * @example\n * ```ts\n * // Custom retry logic and delay\n * await retryAsync(\n *   async () => myFetch('https://api.example.com/data'),\n *   {\n *     maxAttempts: 10,\n *     shouldRetry: (error) => error instanceof NetworkError,\n *     delayInMsCalculator: (attempt) => 100 * attempt,\n *     onAttemptFail: (error, attempt, delay) => {\n *       console.warn(`Attempt ${attempt} failed (waiting ${delay}ms):`, error);\n *     },\n *   }\n * );\n * ```\n */\nexport async function retryAsync<T>(\n  operation: () => T | Promise<T>,\n  options: RetryAsyncOptions = {}\n): Promise<T> {\n  let maxAttempts = options.maxAttempts ?? 5;\n  let shouldRetry = options.shouldRetry ?? ((): boolean => true);\n  let onAttemptFail = options.onAttemptFail;\n  let delayInMsCalculator =\n    options.delayInMsCalculator ?? exponentialBackoffWithJitter;\n\n  if (maxAttempts < 1) {\n    throw new Error('`maxAttempts` must be 1 or greater');\n  }\n  if (maxAttempts > 100) {\n    throw new Error('`maxAttempts` must be 100 or less');\n  }\n\n  let attempts = 1;\n\n  // The \"infinite\" loop here is intentional, and it isn't \"infinite\" in practice.\n  // We have two exit paths for this loop (and one of them will occur eventually):\n  // 1. The operation succeeds and we return the result.\n  // 2. The operation fails and we exceed `maxAttempts` or `shouldRetry` returns `false`,\n  //    and we throw the error. As `maxAttempts` is finite, we will eventually exit here.\n  for (;;) {\n    try {\n      // Exit path 1\n      return await operation();\n    } catch (error) {\n      if (attempts >= maxAttempts || !shouldRetry(error)) {\n        // Exit path 2\n        throw error;\n      }\n\n      const delayInMs = delayInMsCalculator(attempts);\n      onAttemptFail?.(error, attempts, delayInMs);\n      await sleep(delayInMs);\n\n      attempts++;\n    }\n  }\n}\n\n/**\n * Configuration options for {@link retryAsync}.\n */\nexport type RetryAsyncOptions = {\n  /**\n   * The maximum number of attempts to make, including the initial one.\n   * Must be in the range [1, 100].\n   * @default 5\n   */\n  maxAttempts?: number;\n\n  /**\n   * A function to determine if the thrown error should trigger a retry.\n   *\n   * If this function returns `true`, a retry will be performed (up to `maxAttempts`).\n   * If it returns `false`, the error will be immediately thrown and not retried.\n   * @default (error) => true // Retries on any error.\n   * @returns Whether to retry based on the provided error.\n   */\n  shouldRetry?: (error: unknown) => boolean;\n\n  /**\n   * An optional callback executed after a failed attempt, but before the next delay.\n   *\n   * Useful for logging or metrics.\n   * @param error The error that caused the failure.\n   * @param attempt The current failed attempt number (1, 2, 3, etc.).\n   * @param delayInMs The calculated delay before the next attempt.\n   */\n  onAttemptFail?: (error: unknown, attempt: number, delayInMs: number) => void;\n\n  /**\n   * The function that calculates the delay (in milliseconds) before the\n   * next attempt.\n   *\n   * It takes the current attempt number (starting at 1) and returns the delay.\n   * @default Delay calculated using the {@link exponentialBackoffWithJitter} function.\n   *\n   * @returns The delay in milliseconds before the next attempt.\n   */\n  delayInMsCalculator?: (attempt: number) => number;\n};\n"],"names":["exponentialBackoffWithJitter","sleep","retryAsync","operation","options","maxAttempts","shouldRetry","onAttemptFail","delayInMsCalculator","Error","attempts","error","delayInMs"],"mappings":"AAAA,SAASA,4BAA4B,QAAQ,uCAAoC;AACjF,SAASC,KAAK,QAAQ,aAAU;AAEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDC,GACD,OAAO,eAAeC,WACpBC,SAA+B,EAC/BC,UAA6B,CAAC,CAAC;QAEbA,sBACAA,sBAGhBA;IAJF,IAAIC,eAAcD,uBAAAA,QAAQC,WAAW,cAAnBD,kCAAAA,uBAAuB;IACzC,IAAIE,eAAcF,uBAAAA,QAAQE,WAAW,cAAnBF,kCAAAA,uBAAwB,IAAe;IACzD,IAAIG,gBAAgBH,QAAQG,aAAa;IACzC,IAAIC,uBACFJ,+BAAAA,QAAQI,mBAAmB,cAA3BJ,0CAAAA,+BAA+BJ;IAEjC,IAAIK,cAAc,GAAG;QACnB,MAAM,IAAII,MAAM;IAClB;IACA,IAAIJ,cAAc,KAAK;QACrB,MAAM,IAAII,MAAM;IAClB;IAEA,IAAIC,WAAW;IAEf,gFAAgF;IAChF,gFAAgF;IAChF,sDAAsD;IACtD,uFAAuF;IACvF,uFAAuF;IACvF,OAAS;QACP,IAAI;YACF,cAAc;YACd,OAAO,MAAMP;QACf,EAAE,OAAOQ,OAAO;YACd,IAAID,YAAYL,eAAe,CAACC,YAAYK,QAAQ;gBAClD,cAAc;gBACd,MAAMA;YACR;YAEA,MAAMC,YAAYJ,oBAAoBE;YACtCH,0BAAAA,oCAAAA,cAAgBI,OAAOD,UAAUE;YACjC,MAAMX,MAAMW;YAEZF;QACF;IACF;AACF"}

package/dist/sleep.d.ts

@@ -1,7 +1,7 @@
 /**
- * Pauses the execution for a specified duration.
- *
- * @param durationInMs - The duration to sleep in milliseconds.
- * @returns A promise that resolves after the specified duration.
- */
+* Pauses the execution for a specified duration.
+*
+* @param durationInMs - The duration to sleep in milliseconds.
+* @returns A promise that resolves after the specified duration.
+*/
 export declare function sleep(durationInMs: number): Promise<void>;

package/dist/sleep.js

@@ -1,6 +1,10 @@
-//#region libs/shared/underscore/src/sleep.ts
-function e(e) {
-	return new Promise((t) => setTimeout(t, e));
+/**
+ * Pauses the execution for a specified duration.
+ *
+ * @param durationInMs - The duration to sleep in milliseconds.
+ * @returns A promise that resolves after the specified duration.
+ */ export function sleep(durationInMs) {
+    return new Promise((resolve)=>setTimeout(resolve, durationInMs));
 }
-//#endregion
-export { e as sleep };
+
+//# sourceMappingURL=sleep.js.map

package/dist/sleep.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sleep.ts"],"sourcesContent":["/**\n * Pauses the execution for a specified duration.\n *\n * @param durationInMs - The duration to sleep in milliseconds.\n * @returns A promise that resolves after the specified duration.\n */\nexport function sleep(durationInMs: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, durationInMs));\n}\n"],"names":["sleep","durationInMs","Promise","resolve","setTimeout"],"mappings":"AAAA;;;;;CAKC,GACD,OAAO,SAASA,MAAMC,YAAoB;IACxC,OAAO,IAAIC,QAAQ,CAACC,UAAYC,WAAWD,SAASF;AACtD"}

package/dist/string.d.ts

@@ -1,41 +1,41 @@
 /**
- * Capitalizes the first letter of the given string.
- *
- * @param str - The string to capitalize.
- * @returns The input string with the first letter capitalized.
- *
- * @example
- * ```ts
- * capitalizeFirstLetter('hello'); // returns 'Hello'
- * ```
- */
+* Capitalizes the first letter of the given string.
+*
+* @param str - The string to capitalize.
+* @returns The input string with the first letter capitalized.
+*
+* @example
+* ```ts
+* capitalizeFirstLetter('hello'); // returns 'Hello'
+* ```
+*/
 export declare function capitalizeFirstLetter(str: string): string;
 /**
- * Converts a kebab-case string to PascalCase.
- *
- * @param str - The kebab-case string to convert.
- * @returns The converted PascalCase string.
- *
- * @example
- * ```ts
- * kebabToPascalCase('kebab-case-string'); // returns 'KebabCaseString'
- * ```
- */
+* Converts a kebab-case string to PascalCase.
+*
+* @param str - The kebab-case string to convert.
+* @returns The converted PascalCase string.
+*
+* @example
+* ```ts
+* kebabToPascalCase('kebab-case-string'); // returns 'KebabCaseString'
+* ```
+*/
 export declare function kebabToPascalCase(str: string): string;
 /**
- * Converts a given string to kebab-case (dash-case).
- *
- * @param str - The input string to be converted.
- * @returns The kebab-case version of the input string.
- *
- * @example
- * ```ts
- * toKebabCase('HelloWorld'); // Returns 'hello-world'
- * toKebabCase('hello_world'); // Returns 'hello-world'
- * toKebabCase('hello world'); // Returns 'hello-world'
- * toKebabCase('Hello World_Test'); // Returns 'hello-world-test'
- * toKebabCase('special$Char'); // Returns 'special$-char'
- * ```
- *
- * */
+* Converts a given string to kebab-case (dash-case).
+*
+* @param str - The input string to be converted.
+* @returns The kebab-case version of the input string.
+*
+* @example
+* ```ts
+* toKebabCase('HelloWorld'); // Returns 'hello-world'
+* toKebabCase('hello_world'); // Returns 'hello-world'
+* toKebabCase('hello world'); // Returns 'hello-world'
+* toKebabCase('Hello World_Test'); // Returns 'hello-world-test'
+* toKebabCase('special$Char'); // Returns 'special$-char'
+* ```
+*
+* */
 export declare function toKebabCase(str: string): string;

package/dist/string.js

@@ -1,12 +1,51 @@
-//#region libs/shared/underscore/src/string.ts
-function e(e) {
-	return e.charAt(0).toUpperCase() + e.slice(1);
+/**
+ * Capitalizes the first letter of the given string.
+ *
+ * @param str - The string to capitalize.
+ * @returns The input string with the first letter capitalized.
+ *
+ * @example
+ * ```ts
+ * capitalizeFirstLetter('hello'); // returns 'Hello'
+ * ```
+ */ export function capitalizeFirstLetter(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
 }
-function t(e) {
-	return e.replace(/-./g, (e) => e.charAt(1).toUpperCase()).replace(/^\w/, (e) => e.toUpperCase());
+/**
+ * Converts a kebab-case string to PascalCase.
+ *
+ * @param str - The kebab-case string to convert.
+ * @returns The converted PascalCase string.
+ *
+ * @example
+ * ```ts
+ * kebabToPascalCase('kebab-case-string'); // returns 'KebabCaseString'
+ * ```
+ */ export function kebabToPascalCase(str) {
+    return str.replace(/-./g, (match)=>match.charAt(1).toUpperCase()).replace(/^\w/, (c)=>c.toUpperCase());
 }
-function n(e) {
-	return e.replace(/([a-z])([0-9])/gi, "$1-$2").replace(/([0-9])([a-zA-Z])/g, "$1-$2").replace(/([a-z0-9$])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+/**
+ * Converts a given string to kebab-case (dash-case).
+ *
+ * @param str - The input string to be converted.
+ * @returns The kebab-case version of the input string.
+ *
+ * @example
+ * ```ts
+ * toKebabCase('HelloWorld'); // Returns 'hello-world'
+ * toKebabCase('hello_world'); // Returns 'hello-world'
+ * toKebabCase('hello world'); // Returns 'hello-world'
+ * toKebabCase('Hello World_Test'); // Returns 'hello-world-test'
+ * toKebabCase('special$Char'); // Returns 'special$-char'
+ * ```
+ *
+ * */ export function toKebabCase(str) {
+    return str.replace(/([a-z])([0-9])/gi, '$1-$2') // Letter to digit
+    .replace(/([0-9])([a-zA-Z])/g, '$1-$2') // Digit to letter
+    .replace(/([a-z0-9$])([A-Z])/g, '$1-$2') // Add hyphen before uppercase letters
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2') // Handle cases like "HTTPRequest" -> "HTTP-Request"
+    .replace(/[\s_]+/g, '-') // Replace spaces and underscores with hyphens
+    .toLowerCase(); // Convert the entire string to lowercase
 }
-//#endregion
-export { e as capitalizeFirstLetter, t as kebabToPascalCase, n as toKebabCase };
+
+//# sourceMappingURL=string.js.map

package/dist/string.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/string.ts"],"sourcesContent":["/**\n * Capitalizes the first letter of the given string.\n *\n * @param str - The string to capitalize.\n * @returns The input string with the first letter capitalized.\n *\n * @example\n * ```ts\n * capitalizeFirstLetter('hello'); // returns 'Hello'\n * ```\n */\nexport function capitalizeFirstLetter(str: string): string {\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\n/**\n * Converts a kebab-case string to PascalCase.\n *\n * @param str - The kebab-case string to convert.\n * @returns The converted PascalCase string.\n *\n * @example\n * ```ts\n * kebabToPascalCase('kebab-case-string'); // returns 'KebabCaseString'\n * ```\n */\nexport function kebabToPascalCase(str: string): string {\n  return str\n    .replace(/-./g, (match) => match.charAt(1).toUpperCase())\n    .replace(/^\\w/, (c) => c.toUpperCase());\n}\n\n/**\n * Converts a given string to kebab-case (dash-case).\n *\n * @param str - The input string to be converted.\n * @returns The kebab-case version of the input string.\n *\n * @example\n * ```ts\n * toKebabCase('HelloWorld'); // Returns 'hello-world'\n * toKebabCase('hello_world'); // Returns 'hello-world'\n * toKebabCase('hello world'); // Returns 'hello-world'\n * toKebabCase('Hello World_Test'); // Returns 'hello-world-test'\n * toKebabCase('special$Char'); // Returns 'special$-char'\n * ```\n *\n * */\nexport function toKebabCase(str: string): string {\n  return str\n    .replace(/([a-z])([0-9])/gi, '$1-$2') // Letter to digit\n    .replace(/([0-9])([a-zA-Z])/g, '$1-$2') // Digit to letter\n    .replace(/([a-z0-9$])([A-Z])/g, '$1-$2') // Add hyphen before uppercase letters\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2') // Handle cases like \"HTTPRequest\" -> \"HTTP-Request\"\n    .replace(/[\\s_]+/g, '-') // Replace spaces and underscores with hyphens\n    .toLowerCase(); // Convert the entire string to lowercase\n}\n"],"names":["capitalizeFirstLetter","str","charAt","toUpperCase","slice","kebabToPascalCase","replace","match","c","toKebabCase","toLowerCase"],"mappings":"AAAA;;;;;;;;;;CAUC,GACD,OAAO,SAASA,sBAAsBC,GAAW;IAC/C,OAAOA,IAAIC,MAAM,CAAC,GAAGC,WAAW,KAAKF,IAAIG,KAAK,CAAC;AACjD;AAEA;;;;;;;;;;CAUC,GACD,OAAO,SAASC,kBAAkBJ,GAAW;IAC3C,OAAOA,IACJK,OAAO,CAAC,OAAO,CAACC,QAAUA,MAAML,MAAM,CAAC,GAAGC,WAAW,IACrDG,OAAO,CAAC,OAAO,CAACE,IAAMA,EAAEL,WAAW;AACxC;AAEA;;;;;;;;;;;;;;;GAeG,GACH,OAAO,SAASM,YAAYR,GAAW;IACrC,OAAOA,IACJK,OAAO,CAAC,oBAAoB,SAAS,kBAAkB;KACvDA,OAAO,CAAC,sBAAsB,SAAS,kBAAkB;KACzDA,OAAO,CAAC,uBAAuB,SAAS,sCAAsC;KAC9EA,OAAO,CAAC,yBAAyB,SAAS,oDAAoD;KAC9FA,OAAO,CAAC,WAAW,KAAK,8CAA8C;KACtEI,WAAW,IAAI,yCAAyC;AAC7D"}

package/dist/structMap/index.d.ts

@@ -1,3 +1,3 @@
-export { StructMap } from './structMap';
-export type { KeySerializer } from './types';
-export { stableStringify } from './stableStringify';
+export { StructMap } from "./structMap";
+export type { KeySerializer } from "./types";
+export { stableStringify } from "./stableStringify";

package/dist/structMap/index.js

@@ -0,0 +1,4 @@
+export { StructMap } from "./structMap.js";
+export { stableStringify } from "./stableStringify.js";
+
+//# sourceMappingURL=index.js.map

package/dist/structMap/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/structMap/index.ts"],"sourcesContent":["export { StructMap } from './structMap';\nexport type { KeySerializer } from './types';\nexport { stableStringify } from './stableStringify';\n"],"names":["StructMap","stableStringify"],"mappings":"AAAA,SAASA,SAAS,QAAQ,iBAAc;AAExC,SAASC,eAAe,QAAQ,uBAAoB"}

package/dist/structMap/stableStringify.d.ts

@@ -1,23 +1,23 @@
 /**
- * Stringifies any value using JSON.stringify under the hood, but treating certain cases differently.
- * - Objects - Properties are sorted alphabetically to ensure stable output
- * - Non-object values - plain JSON.stringify
- * - Functions, symbols, undefined - removed during serialization
- *
- * @param value - A value to serialize into a string
- * @returns Stringified version of the provided value
- * @throws Throws when BigInt value is encountered at any point or a circular dependency is detected
- *
- * @example
- * ```ts
- * const fileId = { externalId: 'file-1', space: 's1' };
- * const fileIdReversed = { space: 's1', externalId: 'file-1' };
- *
- * console.log(stableStringify(fileId) === stableStringify(fileIdReversed)); // true
- *
- * const user = { name: 'Bob', age: 35, pets: ['Felix', 'Alex'] };
- *
- * console.log(stableStringify(user)); // {"age":35,"name":"Bob","pets":["Felix","Alex"] }
- * ```
- */
+* Stringifies any value using JSON.stringify under the hood, but treating certain cases differently.
+* - Objects - Properties are sorted alphabetically to ensure stable output
+* - Non-object values - plain JSON.stringify
+* - Functions, symbols, undefined - removed during serialization
+*
+* @param value - A value to serialize into a string
+* @returns Stringified version of the provided value
+* @throws Throws when BigInt value is encountered at any point or a circular dependency is detected
+*
+* @example
+* ```ts
+* const fileId = { externalId: 'file-1', space: 's1' };
+* const fileIdReversed = { space: 's1', externalId: 'file-1' };
+*
+* console.log(stableStringify(fileId) === stableStringify(fileIdReversed)); // true
+*
+* const user = { name: 'Bob', age: 35, pets: ['Felix', 'Alex'] };
+*
+* console.log(stableStringify(user)); // {"age":35,"name":"Bob","pets":["Felix","Alex"] }
+* ```
+*/
 export declare function stableStringify(value: unknown): string | undefined;