es-toolkit 1.50.0 → 1.51.0-dev.2069

package/dist/promise/limitAsync.d.mts

@@ -0,0 +1,35 @@
+//#region src/promise/limitAsync.d.ts
+/**
+ * Wraps an async function to limit the number of concurrent executions.
+ *
+ * This function creates a wrapper around an async callback that ensures at most
+ * `concurrency` number of executions can run simultaneously. Additional calls will
+ * wait until a slot becomes available.
+ *
+ * @template F - The type of the async function to wrap.
+ * @param callback The async function to wrap with concurrency control.
+ * @param concurrency Maximum number of concurrent executions allowed.
+ * @returns A wrapped version of the callback with concurrency limiting.
+ * @example
+ * const limitedFetch = limitAsync(async (url) => {
+ *   return await fetch(url);
+ * }, 3);
+ *
+ * // Only 3 fetches will run concurrently
+ * const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
+ * await Promise.all(urls.map(url => limitedFetch(url)));
+ *
+ * @example
+ * const processItem = async (item) => {
+ *   // Expensive async operation
+ *   return await heavyComputation(item);
+ * };
+ *
+ * const limitedProcess = limitAsync(processItem, 2);
+ * const items = [1, 2, 3, 4, 5];
+ * // At most 2 items will be processed concurrently
+ * await Promise.all(items.map(item => limitedProcess(item)));
+ */
+declare function limitAsync<F extends (...args: any[]) => Promise<any>>(callback: F, concurrency: number): F;
+//#endregion
+export { limitAsync };

package/dist/promise/limitAsync.d.ts

@@ -0,0 +1,35 @@
+//#region src/promise/limitAsync.d.ts
+/**
+ * Wraps an async function to limit the number of concurrent executions.
+ *
+ * This function creates a wrapper around an async callback that ensures at most
+ * `concurrency` number of executions can run simultaneously. Additional calls will
+ * wait until a slot becomes available.
+ *
+ * @template F - The type of the async function to wrap.
+ * @param callback The async function to wrap with concurrency control.
+ * @param concurrency Maximum number of concurrent executions allowed.
+ * @returns A wrapped version of the callback with concurrency limiting.
+ * @example
+ * const limitedFetch = limitAsync(async (url) => {
+ *   return await fetch(url);
+ * }, 3);
+ *
+ * // Only 3 fetches will run concurrently
+ * const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
+ * await Promise.all(urls.map(url => limitedFetch(url)));
+ *
+ * @example
+ * const processItem = async (item) => {
+ *   // Expensive async operation
+ *   return await heavyComputation(item);
+ * };
+ *
+ * const limitedProcess = limitAsync(processItem, 2);
+ * const items = [1, 2, 3, 4, 5];
+ * // At most 2 items will be processed concurrently
+ * await Promise.all(items.map(item => limitedProcess(item)));
+ */
+declare function limitAsync<F extends (...args: any[]) => Promise<any>>(callback: F, concurrency: number): F;
+//#endregion
+export { limitAsync };

package/dist/promise/limitAsync.js

@@ -0,0 +1,46 @@
+const require_semaphore = require("./semaphore.js");
+//#region src/promise/limitAsync.ts
+/**
+* Wraps an async function to limit the number of concurrent executions.
+*
+* This function creates a wrapper around an async callback that ensures at most
+* `concurrency` number of executions can run simultaneously. Additional calls will
+* wait until a slot becomes available.
+*
+* @template F - The type of the async function to wrap.
+* @param callback The async function to wrap with concurrency control.
+* @param concurrency Maximum number of concurrent executions allowed.
+* @returns A wrapped version of the callback with concurrency limiting.
+* @example
+* const limitedFetch = limitAsync(async (url) => {
+*   return await fetch(url);
+* }, 3);
+*
+* // Only 3 fetches will run concurrently
+* const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
+* await Promise.all(urls.map(url => limitedFetch(url)));
+*
+* @example
+* const processItem = async (item) => {
+*   // Expensive async operation
+*   return await heavyComputation(item);
+* };
+*
+* const limitedProcess = limitAsync(processItem, 2);
+* const items = [1, 2, 3, 4, 5];
+* // At most 2 items will be processed concurrently
+* await Promise.all(items.map(item => limitedProcess(item)));
+*/
+function limitAsync(callback, concurrency) {
+	const semaphore = new require_semaphore.Semaphore(concurrency);
+	return async function(...args) {
+		try {
+			await semaphore.acquire();
+			return await callback.apply(this, args);
+		} finally {
+			semaphore.release();
+		}
+	};
+}
+//#endregion
+exports.limitAsync = limitAsync;

package/dist/promise/limitAsync.mjs

@@ -0,0 +1,46 @@
+import { Semaphore } from "./semaphore.mjs";
+//#region src/promise/limitAsync.ts
+/**
+* Wraps an async function to limit the number of concurrent executions.
+*
+* This function creates a wrapper around an async callback that ensures at most
+* `concurrency` number of executions can run simultaneously. Additional calls will
+* wait until a slot becomes available.
+*
+* @template F - The type of the async function to wrap.
+* @param callback The async function to wrap with concurrency control.
+* @param concurrency Maximum number of concurrent executions allowed.
+* @returns A wrapped version of the callback with concurrency limiting.
+* @example
+* const limitedFetch = limitAsync(async (url) => {
+*   return await fetch(url);
+* }, 3);
+*
+* // Only 3 fetches will run concurrently
+* const urls = ['url1', 'url2', 'url3', 'url4', 'url5'];
+* await Promise.all(urls.map(url => limitedFetch(url)));
+*
+* @example
+* const processItem = async (item) => {
+*   // Expensive async operation
+*   return await heavyComputation(item);
+* };
+*
+* const limitedProcess = limitAsync(processItem, 2);
+* const items = [1, 2, 3, 4, 5];
+* // At most 2 items will be processed concurrently
+* await Promise.all(items.map(item => limitedProcess(item)));
+*/
+function limitAsync(callback, concurrency) {
+	const semaphore = new Semaphore(concurrency);
+	return async function(...args) {
+		try {
+			await semaphore.acquire();
+			return await callback.apply(this, args);
+		} finally {
+			semaphore.release();
+		}
+	};
+}
+//#endregion
+export { limitAsync };

package/dist/string/dedent.d.mts

@@ -0,0 +1,37 @@
+//#region src/string/dedent.d.ts
+/**
+ * Removes common leading whitespace from each line of a multi-line string.
+ *
+ * This function can be used as a regular function, as a tagged template literal,
+ * or composed with another tag function (TC39 String.dedent proposal).
+ * It calculates the common indentation across all non-empty lines and removes it,
+ * preserving relative indentation differences between lines.
+ * The first and last lines are removed if they are empty or contain only whitespace.
+ *
+ * @param {string | TemplateStringsArray | Function} str - The string, template literal, or tag function to dedent.
+ * @param {unknown[]} values - The values to interpolate when used as a tagged template literal.
+ * @returns {string | Function} The dedented string, or a dedented tag function when composed.
+ *
+ * @example
+ * // As a regular function
+ * dedent("  hello\n  world"); // "hello\nworld"
+ *
+ * @example
+ * // As a tagged template literal
+ * dedent`
+ *   hello
+ *   world
+ * `; // "hello\nworld"
+ *
+ * @example
+ * // Tag composition
+ * const html = dedent((strings, ...values) => strings.join(''));
+ * html`
+ *   <div>Hello</div>
+ * `; // "<div>Hello</div>"
+ */
+declare function dedent(str: string): string;
+declare function dedent(str: TemplateStringsArray, ...values: unknown[]): string;
+declare function dedent<T>(tagFn: (strings: TemplateStringsArray, ...values: unknown[]) => T): (strings: TemplateStringsArray, ...values: unknown[]) => T;
+//#endregion
+export { dedent };

package/dist/string/dedent.d.ts

@@ -0,0 +1,37 @@
+//#region src/string/dedent.d.ts
+/**
+ * Removes common leading whitespace from each line of a multi-line string.
+ *
+ * This function can be used as a regular function, as a tagged template literal,
+ * or composed with another tag function (TC39 String.dedent proposal).
+ * It calculates the common indentation across all non-empty lines and removes it,
+ * preserving relative indentation differences between lines.
+ * The first and last lines are removed if they are empty or contain only whitespace.
+ *
+ * @param {string | TemplateStringsArray | Function} str - The string, template literal, or tag function to dedent.
+ * @param {unknown[]} values - The values to interpolate when used as a tagged template literal.
+ * @returns {string | Function} The dedented string, or a dedented tag function when composed.
+ *
+ * @example
+ * // As a regular function
+ * dedent("  hello\n  world"); // "hello\nworld"
+ *
+ * @example
+ * // As a tagged template literal
+ * dedent`
+ *   hello
+ *   world
+ * `; // "hello\nworld"
+ *
+ * @example
+ * // Tag composition
+ * const html = dedent((strings, ...values) => strings.join(''));
+ * html`
+ *   <div>Hello</div>
+ * `; // "<div>Hello</div>"
+ */
+declare function dedent(str: string): string;
+declare function dedent(str: TemplateStringsArray, ...values: unknown[]): string;
+declare function dedent<T>(tagFn: (strings: TemplateStringsArray, ...values: unknown[]) => T): (strings: TemplateStringsArray, ...values: unknown[]) => T;
+//#endregion
+export { dedent };

package/dist/string/dedent.js

@@ -0,0 +1,38 @@
+//#region src/string/dedent.ts
+function dedent(str, ...values) {
+	switch (typeof str) {
+		case "function": return function(strings, ...args) {
+			return str(dedentTemplateStringsArray(strings), ...args);
+		};
+		case "string": return dedentImpl(str);
+		default: {
+			let text = str[0];
+			for (let i = 0; i < values.length; i++) text += String(values[i]) + str[i + 1];
+			return dedentImpl(text);
+		}
+	}
+}
+function dedentTemplateStringsArray(strings) {
+	const parts = dedentImpl(strings.join("\0")).split("\0");
+	return Object.assign(parts, { raw: parts });
+}
+function dedentImpl(text) {
+	text = text.replace(/\r\n/g, "\n");
+	const lines = text.split("\n");
+	if (lines.length > 0 && lines[0].trim() === "") lines.shift();
+	if (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
+	let commonIndent = Infinity;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line.trim() === "") continue;
+		let indent = 0;
+		while (indent < line.length && (line[indent] === " " || line[indent] === "	")) indent++;
+		if (indent < commonIndent) commonIndent = indent;
+	}
+	if (commonIndent === Infinity) return "";
+	for (let i = 0; i < lines.length; i++) if (lines[i].trim() === "") lines[i] = "";
+	else lines[i] = lines[i].slice(commonIndent);
+	return lines.join("\n");
+}
+//#endregion
+exports.dedent = dedent;

package/dist/string/dedent.mjs

@@ -0,0 +1,38 @@
+//#region src/string/dedent.ts
+function dedent(str, ...values) {
+	switch (typeof str) {
+		case "function": return function(strings, ...args) {
+			return str(dedentTemplateStringsArray(strings), ...args);
+		};
+		case "string": return dedentImpl(str);
+		default: {
+			let text = str[0];
+			for (let i = 0; i < values.length; i++) text += String(values[i]) + str[i + 1];
+			return dedentImpl(text);
+		}
+	}
+}
+function dedentTemplateStringsArray(strings) {
+	const parts = dedentImpl(strings.join("\0")).split("\0");
+	return Object.assign(parts, { raw: parts });
+}
+function dedentImpl(text) {
+	text = text.replace(/\r\n/g, "\n");
+	const lines = text.split("\n");
+	if (lines.length > 0 && lines[0].trim() === "") lines.shift();
+	if (lines.length > 0 && lines[lines.length - 1].trim() === "") lines.pop();
+	let commonIndent = Infinity;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line.trim() === "") continue;
+		let indent = 0;
+		while (indent < line.length && (line[indent] === " " || line[indent] === "	")) indent++;
+		if (indent < commonIndent) commonIndent = indent;
+	}
+	if (commonIndent === Infinity) return "";
+	for (let i = 0; i < lines.length; i++) if (lines[i].trim() === "") lines[i] = "";
+	else lines[i] = lines[i].slice(commonIndent);
+	return lines.join("\n");
+}
+//#endregion
+export { dedent };

package/dist/string/index.d.mts

@@ -2,6 +2,7 @@ import { camelCase } from "./camelCase.mjs";
 import { capitalize } from "./capitalize.mjs";
 import { constantCase } from "./constantCase.mjs";
 import { deburr } from "./deburr.mjs";
+import { dedent } from "./dedent.mjs";
 import { escape } from "./escape.mjs";
 import { escapeRegExp } from "./escapeRegExp.mjs";
 import { kebabCase } from "./kebabCase.mjs";
@@ -19,4 +20,4 @@ import { unescape } from "./unescape.mjs";
 import { upperCase } from "./upperCase.mjs";
 import { upperFirst } from "./upperFirst.mjs";
 import { words } from "./words.mjs";
-export { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };
+export { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };

package/dist/string/index.d.ts

@@ -2,6 +2,7 @@ import { camelCase } from "./camelCase.js";
 import { capitalize } from "./capitalize.js";
 import { constantCase } from "./constantCase.js";
 import { deburr } from "./deburr.js";
+import { dedent } from "./dedent.js";
 import { escape } from "./escape.js";
 import { escapeRegExp } from "./escapeRegExp.js";
 import { kebabCase } from "./kebabCase.js";
@@ -19,4 +20,4 @@ import { unescape } from "./unescape.js";
 import { upperCase } from "./upperCase.js";
 import { upperFirst } from "./upperFirst.js";
 import { words } from "./words.js";
-export { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };
+export { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };

package/dist/string/index.js

@@ -2,16 +2,17 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_capitalize = require("./capitalize.js");
 const require_words = require("./words.js");
 const require_camelCase = require("./camelCase.js");
-const require_snakeCase = require("./snakeCase.js");
 const require_constantCase = require("./constantCase.js");
+const require_kebabCase = require("./kebabCase.js");
+const require_pascalCase = require("./pascalCase.js");
+const require_snakeCase = require("./snakeCase.js");
 const require_deburr = require("./deburr.js");
+const require_dedent = require("./dedent.js");
 const require_escape = require("./escape.js");
 const require_escapeRegExp = require("./escapeRegExp.js");
-const require_kebabCase = require("./kebabCase.js");
 const require_lowerCase = require("./lowerCase.js");
 const require_lowerFirst = require("./lowerFirst.js");
 const require_pad = require("./pad.js");
-const require_pascalCase = require("./pascalCase.js");
 const require_reverseString = require("./reverseString.js");
 const require_startCase = require("./startCase.js");
 const require_trimEnd = require("./trimEnd.js");
@@ -24,6 +25,7 @@ exports.camelCase = require_camelCase.camelCase;
 exports.capitalize = require_capitalize.capitalize;
 exports.constantCase = require_constantCase.constantCase;
 exports.deburr = require_deburr.deburr;
+exports.dedent = require_dedent.dedent;
 exports.escape = require_escape.escape;
 exports.escapeRegExp = require_escapeRegExp.escapeRegExp;
 exports.kebabCase = require_kebabCase.kebabCase;

package/dist/string/index.mjs

@@ -1,16 +1,17 @@
 import { capitalize } from "./capitalize.mjs";
 import { words } from "./words.mjs";
 import { camelCase } from "./camelCase.mjs";
-import { snakeCase } from "./snakeCase.mjs";
 import { constantCase } from "./constantCase.mjs";
+import { kebabCase } from "./kebabCase.mjs";
+import { pascalCase } from "./pascalCase.mjs";
+import { snakeCase } from "./snakeCase.mjs";
 import { deburr } from "./deburr.mjs";
+import { dedent } from "./dedent.mjs";
 import { escape } from "./escape.mjs";
 import { escapeRegExp } from "./escapeRegExp.mjs";
-import { kebabCase } from "./kebabCase.mjs";
 import { lowerCase } from "./lowerCase.mjs";
 import { lowerFirst } from "./lowerFirst.mjs";
 import { pad } from "./pad.mjs";
-import { pascalCase } from "./pascalCase.mjs";
 import { reverseString } from "./reverseString.mjs";
 import { startCase } from "./startCase.mjs";
 import { trimEnd } from "./trimEnd.mjs";
@@ -19,4 +20,4 @@ import { trim } from "./trim.mjs";
 import { unescape } from "./unescape.mjs";
 import { upperCase } from "./upperCase.mjs";
 import { upperFirst } from "./upperFirst.mjs";
-export { camelCase, capitalize, constantCase, deburr, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };
+export { camelCase, capitalize, constantCase, deburr, dedent, escape, escapeRegExp, kebabCase, lowerCase, lowerFirst, pad, pascalCase, reverseString, snakeCase, startCase, trim, trimEnd, trimStart, unescape, upperCase, upperFirst, words };

package/dist/types/ToCamelCaseKeys.d.mts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToCamelCaseKeys.d.ts
+type SnakeToCamel<S extends string> = S extends `${infer H}_${infer T}` ? `${Lowercase<H>}${Capitalize<SnakeToCamel<T>>}` : Lowercase<S>;
+type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase the entire string; otherwise, just lowercase the first letter (including PascalCase → camelCase). */
+type AnyToCamel<S extends string> = S extends `${string}_${string}` ? SnakeToCamel<S> : S extends Uppercase<S> ? Lowercase<S> : PascalToCamel<S>;
+/**
+ * Converts the keys of `T` to camelCase recursively.
+ *
+ * This is the return type of the `toCamelCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { user_id: number; first_name: string };
+ * type Converted = ToCamelCaseKeys<Response>;
+ * // => { userId: number; firstName: string }
+ */
+type ToCamelCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToCamelCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToCamel<Extract<K, string>>]: ToCamelCaseKeys<T[K]> } : T;
+//#endregion
+export { ToCamelCaseKeys };

package/dist/types/ToCamelCaseKeys.d.ts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToCamelCaseKeys.d.ts
+type SnakeToCamel<S extends string> = S extends `${infer H}_${infer T}` ? `${Lowercase<H>}${Capitalize<SnakeToCamel<T>>}` : Lowercase<S>;
+type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase the entire string; otherwise, just lowercase the first letter (including PascalCase → camelCase). */
+type AnyToCamel<S extends string> = S extends `${string}_${string}` ? SnakeToCamel<S> : S extends Uppercase<S> ? Lowercase<S> : PascalToCamel<S>;
+/**
+ * Converts the keys of `T` to camelCase recursively.
+ *
+ * This is the return type of the `toCamelCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { user_id: number; first_name: string };
+ * type Converted = ToCamelCaseKeys<Response>;
+ * // => { userId: number; firstName: string }
+ */
+type ToCamelCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToCamelCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToCamel<Extract<K, string>>]: ToCamelCaseKeys<T[K]> } : T;
+//#endregion
+export { ToCamelCaseKeys };

package/dist/types/ToConstantCaseKeys.d.mts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToConstantCaseKeys.d.ts
+type ConstantCase<S extends string> = S extends Lowercase<S> ? Uppercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Uppercase<P1>}${ConstantCase<P2>}` : `${Uppercase<P1>}_${ConstantCase<Uncapitalize<P2>>}` : Uppercase<S>;
+/**
+ * Converts the keys of `T` to CONSTANT_CASE recursively.
+ *
+ * This is the return type of the `toConstantCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToConstantCaseKeys<Response>;
+ * // => { USER_ID: number; FIRST_NAME: string }
+ */
+type ToConstantCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToConstantCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as ConstantCase<string & K>]: ToConstantCaseKeys<T[K]> } : T;
+//#endregion
+export { ToConstantCaseKeys };

package/dist/types/ToConstantCaseKeys.d.ts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToConstantCaseKeys.d.ts
+type ConstantCase<S extends string> = S extends Lowercase<S> ? Uppercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Uppercase<P1>}${ConstantCase<P2>}` : `${Uppercase<P1>}_${ConstantCase<Uncapitalize<P2>>}` : Uppercase<S>;
+/**
+ * Converts the keys of `T` to CONSTANT_CASE recursively.
+ *
+ * This is the return type of the `toConstantCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToConstantCaseKeys<Response>;
+ * // => { USER_ID: number; FIRST_NAME: string }
+ */
+type ToConstantCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToConstantCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as ConstantCase<string & K>]: ToConstantCaseKeys<T[K]> } : T;
+//#endregion
+export { ToConstantCaseKeys };

package/dist/types/ToKebabCaseKeys.d.mts

@@ -0,0 +1,23 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToKebabCaseKeys.d.ts
+type SnakeToKebab<S extends string> = S extends `${infer P1}_${infer P2}` ? Lowercase<`${P1}-${SnakeToKebab<P2>}`> : Lowercase<S>;
+type CamelToKebab<S extends string> = S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${CamelToKebab<P2>}` : `${Lowercase<P1>}-${CamelToKebab<Uncapitalize<P2>>}` : S;
+type KebabCase<S extends string> = S extends `${string}_${string}` ? SnakeToKebab<S> : S extends Uppercase<S> ? Lowercase<S> : CamelToKebab<S>;
+/**
+ * Converts the keys of `T` to kebab-case recursively.
+ *
+ * This is the return type of the `toKebabCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToKebabCaseKeys<Response>;
+ * // => { 'user-id': number; 'first-name': string }
+ */
+type ToKebabCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToKebabCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as KebabCase<string & K>]: ToKebabCaseKeys<T[K]> } : T;
+//#endregion
+export { ToKebabCaseKeys };

package/dist/types/ToKebabCaseKeys.d.ts

@@ -0,0 +1,23 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToKebabCaseKeys.d.ts
+type SnakeToKebab<S extends string> = S extends `${infer P1}_${infer P2}` ? Lowercase<`${P1}-${SnakeToKebab<P2>}`> : Lowercase<S>;
+type CamelToKebab<S extends string> = S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${CamelToKebab<P2>}` : `${Lowercase<P1>}-${CamelToKebab<Uncapitalize<P2>>}` : S;
+type KebabCase<S extends string> = S extends `${string}_${string}` ? SnakeToKebab<S> : S extends Uppercase<S> ? Lowercase<S> : CamelToKebab<S>;
+/**
+ * Converts the keys of `T` to kebab-case recursively.
+ *
+ * This is the return type of the `toKebabCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToKebabCaseKeys<Response>;
+ * // => { 'user-id': number; 'first-name': string }
+ */
+type ToKebabCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToKebabCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as KebabCase<string & K>]: ToKebabCaseKeys<T[K]> } : T;
+//#endregion
+export { ToKebabCaseKeys };

package/dist/types/ToPascalCaseKeys.d.mts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToPascalCaseKeys.d.ts
+type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}` ? `${Capitalize<Lowercase<H>>}${Capitalize<SnakeToPascal<T>>}` : Capitalize<Lowercase<S>>;
+type CamelToPascal<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase and capitalize the entire string; otherwise, just uppercase the first letter (including camelCase → PascalCase). */
+type AnyToPascal<S extends string> = S extends `${string}_${string}` ? SnakeToPascal<S> : S extends Uppercase<S> ? Capitalize<Lowercase<S>> : CamelToPascal<S>;
+/**
+ * Converts the keys of `T` to PascalCase recursively.
+ *
+ * This is the return type of the `toPascalCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToPascalCaseKeys<Response>;
+ * // => { UserId: number; FirstName: string }
+ */
+type ToPascalCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToPascalCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToPascal<Extract<K, string>>]: ToPascalCaseKeys<T[K]> } : T;
+//#endregion
+export { ToPascalCaseKeys };

package/dist/types/ToPascalCaseKeys.d.ts

@@ -0,0 +1,24 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToPascalCaseKeys.d.ts
+type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}` ? `${Capitalize<Lowercase<H>>}${Capitalize<SnakeToPascal<T>>}` : Capitalize<Lowercase<S>>;
+type CamelToPascal<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase and capitalize the entire string; otherwise, just uppercase the first letter (including camelCase → PascalCase). */
+type AnyToPascal<S extends string> = S extends `${string}_${string}` ? SnakeToPascal<S> : S extends Uppercase<S> ? Capitalize<Lowercase<S>> : CamelToPascal<S>;
+/**
+ * Converts the keys of `T` to PascalCase recursively.
+ *
+ * This is the return type of the `toPascalCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Response = { userId: number; firstName: string };
+ * type Converted = ToPascalCaseKeys<Response>;
+ * // => { UserId: number; FirstName: string }
+ */
+type ToPascalCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToPascalCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToPascal<Extract<K, string>>]: ToPascalCaseKeys<T[K]> } : T;
+//#endregion
+export { ToPascalCaseKeys };

package/dist/types/ToSnakeCaseKeys.d.mts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.mjs";
+
+//#region src/types/ToSnakeCaseKeys.d.ts
+type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
+/**
+ * Converts the keys of `T` to snake_case recursively.
+ *
+ * This is the return type of the `toSnakeCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Request = { userId: number; firstName: string };
+ * type Converted = ToSnakeCaseKeys<Request>;
+ * // => { user_id: number; first_name: string }
+ */
+type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
+//#endregion
+export { ToSnakeCaseKeys };

package/dist/types/ToSnakeCaseKeys.d.ts

@@ -0,0 +1,21 @@
+import { NonPlainObject } from "../_internal/NonPlainObject.js";
+
+//#region src/types/ToSnakeCaseKeys.d.ts
+type SnakeCase<S extends string> = S extends Uppercase<S> ? Lowercase<S> : S extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Lowercase<P1>}${SnakeCase<P2>}` : `${Lowercase<P1>}_${SnakeCase<Uncapitalize<P2>>}` : Lowercase<S>;
+/**
+ * Converts the keys of `T` to snake_case recursively.
+ *
+ * This is the return type of the `toSnakeCaseKeys` function. Recurses into
+ * plain objects and arrays; built-in objects like `Date`, `Map`, and functions
+ * pass through unchanged.
+ *
+ * @template T - The type whose keys are converted.
+ *
+ * @example
+ * type Request = { userId: number; firstName: string };
+ * type Converted = ToSnakeCaseKeys<Request>;
+ * // => { user_id: number; first_name: string }
+ */
+type ToSnakeCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToSnakeCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as SnakeCase<string & K>]: ToSnakeCaseKeys<T[K]> } : T;
+//#endregion
+export { ToSnakeCaseKeys };