es-toolkit 1.50.0-dev.2000 → 1.50.0-dev.2025

package/dist/object/index.d.mts

@@ -14,6 +14,9 @@ import { pick } from "./pick.mjs";
 import { pickBy } from "./pickBy.mjs";
 import { sortKeys } from "./sortKeys.mjs";
 import { toCamelCaseKeys } from "./toCamelCaseKeys.mjs";
+import { toConstantCaseKeys } from "./toConstantCaseKeys.mjs";
+import { toKebabCaseKeys } from "./toKebabCaseKeys.mjs";
 import { toMerged } from "./toMerged.mjs";
+import { toPascalCaseKeys } from "./toPascalCaseKeys.mjs";
 import { toSnakeCaseKeys } from "./toSnakeCaseKeys.mjs";
-export { clone, cloneDeep, cloneDeepWith, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toMerged, toSnakeCaseKeys };
+export { clone, cloneDeep, cloneDeepWith, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toConstantCaseKeys, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys };

package/dist/object/index.d.ts

@@ -14,6 +14,9 @@ import { pick } from "./pick.js";
 import { pickBy } from "./pickBy.js";
 import { sortKeys } from "./sortKeys.js";
 import { toCamelCaseKeys } from "./toCamelCaseKeys.js";
+import { toConstantCaseKeys } from "./toConstantCaseKeys.js";
+import { toKebabCaseKeys } from "./toKebabCaseKeys.js";
 import { toMerged } from "./toMerged.js";
+import { toPascalCaseKeys } from "./toPascalCaseKeys.js";
 import { toSnakeCaseKeys } from "./toSnakeCaseKeys.js";
-export { clone, cloneDeep, cloneDeepWith, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toMerged, toSnakeCaseKeys };
+export { clone, cloneDeep, cloneDeepWith, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toConstantCaseKeys, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys };

package/dist/object/index.js

@@ -15,7 +15,10 @@ const require_pick = require("./pick.js");
 const require_pickBy = require("./pickBy.js");
 const require_sortKeys = require("./sortKeys.js");
 const require_toCamelCaseKeys = require("./toCamelCaseKeys.js");
+const require_toConstantCaseKeys = require("./toConstantCaseKeys.js");
+const require_toKebabCaseKeys = require("./toKebabCaseKeys.js");
 const require_toMerged = require("./toMerged.js");
+const require_toPascalCaseKeys = require("./toPascalCaseKeys.js");
 const require_toSnakeCaseKeys = require("./toSnakeCaseKeys.js");
 exports.clone = require_clone.clone;
 exports.cloneDeep = require_cloneDeep.cloneDeep;
@@ -33,5 +36,8 @@ exports.pick = require_pick.pick;
 exports.pickBy = require_pickBy.pickBy;
 exports.sortKeys = require_sortKeys.sortKeys;
 exports.toCamelCaseKeys = require_toCamelCaseKeys.toCamelCaseKeys;
+exports.toConstantCaseKeys = require_toConstantCaseKeys.toConstantCaseKeys;
+exports.toKebabCaseKeys = require_toKebabCaseKeys.toKebabCaseKeys;
 exports.toMerged = require_toMerged.toMerged;
+exports.toPascalCaseKeys = require_toPascalCaseKeys.toPascalCaseKeys;
 exports.toSnakeCaseKeys = require_toSnakeCaseKeys.toSnakeCaseKeys;

package/dist/object/index.mjs

@@ -14,6 +14,9 @@ import { pick } from "./pick.mjs";
 import { pickBy } from "./pickBy.mjs";
 import { sortKeys } from "./sortKeys.mjs";
 import { toCamelCaseKeys } from "./toCamelCaseKeys.mjs";
+import { toConstantCaseKeys } from "./toConstantCaseKeys.mjs";
+import { toKebabCaseKeys } from "./toKebabCaseKeys.mjs";
 import { toMerged } from "./toMerged.mjs";
+import { toPascalCaseKeys } from "./toPascalCaseKeys.mjs";
 import { toSnakeCaseKeys } from "./toSnakeCaseKeys.mjs";
-export { clone, cloneDeep, cloneDeepWith, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toMerged, toSnakeCaseKeys };
+export { clone, cloneDeep, cloneDeepWith, findKey, flattenObject, invert, mapKeys, mapValues, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toConstantCaseKeys, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys };

package/dist/object/toConstantCaseKeys.d.mts

@@ -0,0 +1,53 @@
+//#region src/object/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>;
+type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
+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;
+/**
+ * Creates a new object composed of the properties with keys converted to CONSTANT_CASE.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to CONSTANT_CASE format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to CONSTANT_CASE.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toConstantCaseKeys(obj);
+ * // result will be { USER_ID: 1, FIRST_NAME: 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toConstantCaseKeys(arr);
+ * // arrResult will be [{ USER_ID: 1, FIRST_NAME: 'John' }, { USER_ID: 2, FIRST_NAME: 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toConstantCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   USER_DATA: {
+ * //     USER_ID: 1,
+ * //     USER_ADDRESS: {
+ * //       STREET_NAME: 'Main St',
+ * //       ZIP_CODE: '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toConstantCaseKeys<T>(obj: T): ToConstantCaseKeys<T>;
+//#endregion
+export { toConstantCaseKeys };

package/dist/object/toConstantCaseKeys.d.ts

@@ -0,0 +1,53 @@
+//#region src/object/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>;
+type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
+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;
+/**
+ * Creates a new object composed of the properties with keys converted to CONSTANT_CASE.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to CONSTANT_CASE format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to CONSTANT_CASE.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toConstantCaseKeys(obj);
+ * // result will be { USER_ID: 1, FIRST_NAME: 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toConstantCaseKeys(arr);
+ * // arrResult will be [{ USER_ID: 1, FIRST_NAME: 'John' }, { USER_ID: 2, FIRST_NAME: 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toConstantCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   USER_DATA: {
+ * //     USER_ID: 1,
+ * //     USER_ADDRESS: {
+ * //       STREET_NAME: 'Main St',
+ * //       ZIP_CODE: '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toConstantCaseKeys<T>(obj: T): ToConstantCaseKeys<T>;
+//#endregion
+export { toConstantCaseKeys };

package/dist/object/toConstantCaseKeys.js

@@ -0,0 +1,66 @@
+const require_isArray = require("../compat/predicate/isArray.js");
+const require_isPlainObject = require("../compat/predicate/isPlainObject.js");
+const require_constantCase = require("../string/constantCase.js");
+//#region src/object/toConstantCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to CONSTANT_CASE.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to CONSTANT_CASE format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to CONSTANT_CASE.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toConstantCaseKeys(obj);
+* // result will be { USER_ID: 1, FIRST_NAME: 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toConstantCaseKeys(arr);
+* // arrResult will be [{ USER_ID: 1, FIRST_NAME: 'John' }, { USER_ID: 2, FIRST_NAME: 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toConstantCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   USER_DATA: {
+* //     USER_ID: 1,
+* //     USER_ADDRESS: {
+* //       STREET_NAME: 'Main St',
+* //       ZIP_CODE: '12345'
+* //     }
+* //   }
+* // }
+*/
+function toConstantCaseKeys(obj) {
+	if (require_isArray.isArray(obj)) return obj.map((item) => toConstantCaseKeys(item));
+	if (require_isPlainObject.isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const constantKey = require_constantCase.constantCase(key);
+			result[constantKey] = toConstantCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+exports.toConstantCaseKeys = toConstantCaseKeys;

package/dist/object/toConstantCaseKeys.mjs

@@ -0,0 +1,66 @@
+import { isArray } from "../compat/predicate/isArray.mjs";
+import { isPlainObject } from "../compat/predicate/isPlainObject.mjs";
+import { constantCase } from "../string/constantCase.mjs";
+//#region src/object/toConstantCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to CONSTANT_CASE.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to CONSTANT_CASE format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to CONSTANT_CASE.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toConstantCaseKeys(obj);
+* // result will be { USER_ID: 1, FIRST_NAME: 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toConstantCaseKeys(arr);
+* // arrResult will be [{ USER_ID: 1, FIRST_NAME: 'John' }, { USER_ID: 2, FIRST_NAME: 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toConstantCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   USER_DATA: {
+* //     USER_ID: 1,
+* //     USER_ADDRESS: {
+* //       STREET_NAME: 'Main St',
+* //       ZIP_CODE: '12345'
+* //     }
+* //   }
+* // }
+*/
+function toConstantCaseKeys(obj) {
+	if (isArray(obj)) return obj.map((item) => toConstantCaseKeys(item));
+	if (isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const constantKey = constantCase(key);
+			result[constantKey] = toConstantCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+export { toConstantCaseKeys };

package/dist/object/toKebabCaseKeys.d.mts

@@ -0,0 +1,55 @@
+//#region src/object/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>;
+type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
+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;
+/**
+ * Creates a new object composed of the properties with keys converted to kebab-case.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to kebab-case format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to kebab-case.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toKebabCaseKeys(obj);
+ * // result will be { 'user-id': 1, 'first-name': 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toKebabCaseKeys(arr);
+ * // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toKebabCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   'user-data': {
+ * //     'user-id': 1,
+ * //     'user-address': {
+ * //       'street-name': 'Main St',
+ * //       'zip-code': '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toKebabCaseKeys<T>(obj: T): ToKebabCaseKeys<T>;
+//#endregion
+export { toKebabCaseKeys };

package/dist/object/toKebabCaseKeys.d.ts

@@ -0,0 +1,55 @@
+//#region src/object/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>;
+type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
+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;
+/**
+ * Creates a new object composed of the properties with keys converted to kebab-case.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to kebab-case format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to kebab-case.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toKebabCaseKeys(obj);
+ * // result will be { 'user-id': 1, 'first-name': 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toKebabCaseKeys(arr);
+ * // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toKebabCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   'user-data': {
+ * //     'user-id': 1,
+ * //     'user-address': {
+ * //       'street-name': 'Main St',
+ * //       'zip-code': '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toKebabCaseKeys<T>(obj: T): ToKebabCaseKeys<T>;
+//#endregion
+export { toKebabCaseKeys };

package/dist/object/toKebabCaseKeys.js

@@ -0,0 +1,66 @@
+const require_isArray = require("../compat/predicate/isArray.js");
+const require_isPlainObject = require("../compat/predicate/isPlainObject.js");
+const require_kebabCase = require("../string/kebabCase.js");
+//#region src/object/toKebabCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to kebab-case.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to kebab-case format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to kebab-case.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toKebabCaseKeys(obj);
+* // result will be { 'user-id': 1, 'first-name': 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toKebabCaseKeys(arr);
+* // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toKebabCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   'user-data': {
+* //     'user-id': 1,
+* //     'user-address': {
+* //       'street-name': 'Main St',
+* //       'zip-code': '12345'
+* //     }
+* //   }
+* // }
+*/
+function toKebabCaseKeys(obj) {
+	if (require_isArray.isArray(obj)) return obj.map((item) => toKebabCaseKeys(item));
+	if (require_isPlainObject.isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const kebabKey = require_kebabCase.kebabCase(key);
+			result[kebabKey] = toKebabCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+exports.toKebabCaseKeys = toKebabCaseKeys;

package/dist/object/toKebabCaseKeys.mjs

@@ -0,0 +1,66 @@
+import { isArray } from "../compat/predicate/isArray.mjs";
+import { isPlainObject } from "../compat/predicate/isPlainObject.mjs";
+import { kebabCase } from "../string/kebabCase.mjs";
+//#region src/object/toKebabCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to kebab-case.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to kebab-case format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to kebab-case.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toKebabCaseKeys(obj);
+* // result will be { 'user-id': 1, 'first-name': 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toKebabCaseKeys(arr);
+* // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toKebabCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   'user-data': {
+* //     'user-id': 1,
+* //     'user-address': {
+* //       'street-name': 'Main St',
+* //       'zip-code': '12345'
+* //     }
+* //   }
+* // }
+*/
+function toKebabCaseKeys(obj) {
+	if (isArray(obj)) return obj.map((item) => toKebabCaseKeys(item));
+	if (isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const kebabKey = kebabCase(key);
+			result[kebabKey] = toKebabCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+export { toKebabCaseKeys };

package/dist/object/toPascalCaseKeys.d.mts

@@ -0,0 +1,56 @@
+//#region src/object/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>;
+type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
+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;
+/**
+ * Creates a new object composed of the properties with keys converted to PascalCase.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to PascalCase format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to PascalCase.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toPascalCaseKeys(obj);
+ * // result will be { UserId: 1, FirstName: 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toPascalCaseKeys(arr);
+ * // arrResult will be [{ UserId: 1, FirstName: 'John' }, { UserId: 2, FirstName: 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toPascalCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   UserData: {
+ * //     UserId: 1,
+ * //     UserAddress: {
+ * //       StreetName: 'Main St',
+ * //       ZipCode: '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toPascalCaseKeys<T>(obj: T): ToPascalCaseKeys<T>;
+//#endregion
+export { toPascalCaseKeys };

package/dist/object/toPascalCaseKeys.d.ts

@@ -0,0 +1,56 @@
+//#region src/object/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>;
+type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
+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;
+/**
+ * Creates a new object composed of the properties with keys converted to PascalCase.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to PascalCase format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to PascalCase.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toPascalCaseKeys(obj);
+ * // result will be { UserId: 1, FirstName: 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toPascalCaseKeys(arr);
+ * // arrResult will be [{ UserId: 1, FirstName: 'John' }, { UserId: 2, FirstName: 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toPascalCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   UserData: {
+ * //     UserId: 1,
+ * //     UserAddress: {
+ * //       StreetName: 'Main St',
+ * //       ZipCode: '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toPascalCaseKeys<T>(obj: T): ToPascalCaseKeys<T>;
+//#endregion
+export { toPascalCaseKeys };