es-toolkit 1.50.0-dev.2001 → 1.50.0-dev.2026

package/dist/index.d.ts

@@ -121,7 +121,10 @@ import { pick } from "./object/pick.js";
 import { pickBy } from "./object/pickBy.js";
 import { sortKeys } from "./object/sortKeys.js";
 import { toCamelCaseKeys } from "./object/toCamelCaseKeys.js";
+import { toConstantCaseKeys } from "./object/toConstantCaseKeys.js";
+import { toKebabCaseKeys } from "./object/toKebabCaseKeys.js";
 import { toMerged } from "./object/toMerged.js";
+import { toPascalCaseKeys } from "./object/toPascalCaseKeys.js";
 import { toSnakeCaseKeys } from "./object/toSnakeCaseKeys.js";
 import { isArrayBuffer } from "./predicate/isArrayBuffer.js";
 import { isBlob } from "./predicate/isBlob.js";
@@ -185,4 +188,4 @@ import { words } from "./string/words.js";
 import { attempt } from "./util/attempt.js";
 import { attemptAsync } from "./util/attemptAsync.js";
 import { invariant } from "./util/invariant.js";
-export { AbortError, DebounceOptions, DebouncedFunction, MemoizeCache, Mutex, Semaphore, ThrottleOptions, ThrottledFunction, TimeoutError, after, allKeyed, ary, invariant as assert, asyncNoop, at, attempt, attemptAsync, before, camelCase, capitalize, cartesianProduct, chunk, chunkBy, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, escape, escapeRegExp, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowRight, forEachAsync, forEachRight, groupBy, head, identity, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, remove, rest, retry, reverseString, round, sample, sampleSize, shuffle, snakeCase, sortBy, sortKeys, spread, startCase, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, throttle, timeout, toCamelCaseKeys, toFilled, toMerged, toSnakeCaseKeys, trim, trimEnd, trimStart, unary, unescape, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, upperCase, upperFirst, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };
+export { AbortError, DebounceOptions, DebouncedFunction, MemoizeCache, Mutex, Semaphore, ThrottleOptions, ThrottledFunction, TimeoutError, after, allKeyed, ary, invariant as assert, asyncNoop, at, attempt, attemptAsync, before, camelCase, capitalize, cartesianProduct, chunk, chunkBy, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, escape, escapeRegExp, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowRight, forEachAsync, forEachRight, groupBy, head, identity, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, remove, rest, retry, reverseString, round, sample, sampleSize, shuffle, snakeCase, sortBy, sortKeys, spread, startCase, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, throttle, timeout, toCamelCaseKeys, toConstantCaseKeys, toFilled, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys, trim, trimEnd, trimStart, unary, unescape, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, upperCase, upperFirst, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };

package/dist/index.js

@@ -134,7 +134,13 @@ const require_capitalize = require("./string/capitalize.js");
 const require_words = require("./string/words.js");
 const require_camelCase = require("./string/camelCase.js");
 const require_toCamelCaseKeys = require("./object/toCamelCaseKeys.js");
+const require_constantCase = require("./string/constantCase.js");
+const require_toConstantCaseKeys = require("./object/toConstantCaseKeys.js");
+const require_kebabCase = require("./string/kebabCase.js");
+const require_toKebabCaseKeys = require("./object/toKebabCaseKeys.js");
 const require_toMerged = require("./object/toMerged.js");
+const require_pascalCase = require("./string/pascalCase.js");
+const require_toPascalCaseKeys = require("./object/toPascalCaseKeys.js");
 const require_snakeCase = require("./string/snakeCase.js");
 const require_toSnakeCaseKeys = require("./object/toSnakeCaseKeys.js");
 require("./object/index.js");
@@ -173,15 +179,12 @@ const require_mutex = require("./promise/mutex.js");
 const require_timeout = require("./promise/timeout.js");
 const require_withTimeout = require("./promise/withTimeout.js");
 require("./promise/index.js");
-const require_constantCase = require("./string/constantCase.js");
 const require_deburr = require("./string/deburr.js");
 const require_escape = require("./string/escape.js");
 const require_escapeRegExp = require("./string/escapeRegExp.js");
-const require_kebabCase = require("./string/kebabCase.js");
 const require_lowerCase = require("./string/lowerCase.js");
 const require_lowerFirst = require("./string/lowerFirst.js");
 const require_pad = require("./string/pad.js");
-const require_pascalCase = require("./string/pascalCase.js");
 const require_reverseString = require("./string/reverseString.js");
 const require_startCase = require("./string/startCase.js");
 const require_trimEnd = require("./string/trimEnd.js");
@@ -357,8 +360,11 @@ exports.takeWhile = require_takeWhile.takeWhile;
 exports.throttle = require_throttle.throttle;
 exports.timeout = require_timeout.timeout;
 exports.toCamelCaseKeys = require_toCamelCaseKeys.toCamelCaseKeys;
+exports.toConstantCaseKeys = require_toConstantCaseKeys.toConstantCaseKeys;
 exports.toFilled = require_toFilled.toFilled;
+exports.toKebabCaseKeys = require_toKebabCaseKeys.toKebabCaseKeys;
 exports.toMerged = require_toMerged.toMerged;
+exports.toPascalCaseKeys = require_toPascalCaseKeys.toPascalCaseKeys;
 exports.toSnakeCaseKeys = require_toSnakeCaseKeys.toSnakeCaseKeys;
 exports.trim = require_trim.trim;
 exports.trimEnd = require_trimEnd.trimEnd;

package/dist/index.mjs

@@ -133,7 +133,13 @@ import { capitalize } from "./string/capitalize.mjs";
 import { words } from "./string/words.mjs";
 import { camelCase } from "./string/camelCase.mjs";
 import { toCamelCaseKeys } from "./object/toCamelCaseKeys.mjs";
+import { constantCase } from "./string/constantCase.mjs";
+import { toConstantCaseKeys } from "./object/toConstantCaseKeys.mjs";
+import { kebabCase } from "./string/kebabCase.mjs";
+import { toKebabCaseKeys } from "./object/toKebabCaseKeys.mjs";
 import { toMerged } from "./object/toMerged.mjs";
+import { pascalCase } from "./string/pascalCase.mjs";
+import { toPascalCaseKeys } from "./object/toPascalCaseKeys.mjs";
 import { snakeCase } from "./string/snakeCase.mjs";
 import { toSnakeCaseKeys } from "./object/toSnakeCaseKeys.mjs";
 import "./object/index.mjs";
@@ -172,15 +178,12 @@ import { Mutex } from "./promise/mutex.mjs";
 import { timeout } from "./promise/timeout.mjs";
 import { withTimeout } from "./promise/withTimeout.mjs";
 import "./promise/index.mjs";
-import { constantCase } from "./string/constantCase.mjs";
 import { deburr } from "./string/deburr.mjs";
 import { escape } from "./string/escape.mjs";
 import { escapeRegExp } from "./string/escapeRegExp.mjs";
-import { kebabCase } from "./string/kebabCase.mjs";
 import { lowerCase } from "./string/lowerCase.mjs";
 import { lowerFirst } from "./string/lowerFirst.mjs";
 import { pad } from "./string/pad.mjs";
-import { pascalCase } from "./string/pascalCase.mjs";
 import { reverseString } from "./string/reverseString.mjs";
 import { startCase } from "./string/startCase.mjs";
 import { trimEnd } from "./string/trimEnd.mjs";
@@ -194,4 +197,4 @@ import { attempt } from "./util/attempt.mjs";
 import { attemptAsync } from "./util/attemptAsync.mjs";
 import { invariant } from "./util/invariant.mjs";
 import "./util/index.mjs";
-export { AbortError, Mutex, Semaphore, TimeoutError, after, allKeyed, ary, invariant as assert, asyncNoop, at, attempt, attemptAsync, before, camelCase, capitalize, cartesianProduct, chunk, chunkBy, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, escape, escapeRegExp, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowRight, forEachAsync, forEachRight, groupBy, head, identity, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, remove, rest, retry, reverseString, round, sample, sampleSize, shuffle, snakeCase, sortBy, sortKeys, spread, startCase, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, throttle, timeout, toCamelCaseKeys, toFilled, toMerged, toSnakeCaseKeys, trim, trimEnd, trimStart, unary, unescape, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, upperCase, upperFirst, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };
+export { AbortError, Mutex, Semaphore, TimeoutError, after, allKeyed, ary, invariant as assert, asyncNoop, at, attempt, attemptAsync, before, camelCase, capitalize, cartesianProduct, chunk, chunkBy, clamp, clone, cloneDeep, cloneDeepWith, combinations, compact, constantCase, countBy, curry, curryRight, debounce, deburr, delay, difference, differenceBy, differenceWith, drop, dropRight, dropRightWhile, dropWhile, escape, escapeRegExp, fill, filterAsync, findKey, flatMap, flatMapAsync, flatMapDeep, flatten, flattenDeep, flattenObject, flow, flowRight, forEachAsync, forEachRight, groupBy, head, identity, inRange, initial, intersection, intersectionBy, intersectionWith, invariant, invert, isArrayBuffer, isBlob, isBoolean, isBrowser, isBuffer, isDate, isEmptyObject, isEqual, isEqualWith, isError, isFile, isFunction, isIterable, isJSON, isJSONArray, isJSONObject, isJSONValue, isLength, isMap, isNil, isNode, isNotNil, isNull, isNumber, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSubset, isSubsetWith, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet, kebabCase, keyBy, last, limitAsync, lowerCase, lowerFirst, mapAsync, mapKeys, mapValues, maxBy, mean, meanBy, median, medianBy, memoize, merge, mergeWith, minBy, negate, noop, omit, omitBy, once, orderBy, pad, partial, partialRight, partition, pascalCase, percentile, pick, pickBy, pull, pullAt, random, randomInt, range, rangeRight, reduceAsync, remove, rest, retry, reverseString, round, sample, sampleSize, shuffle, snakeCase, sortBy, sortKeys, spread, startCase, sum, sumBy, tail, take, takeRight, takeRightWhile, takeWhile, throttle, timeout, toCamelCaseKeys, toConstantCaseKeys, toFilled, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys, trim, trimEnd, trimStart, unary, unescape, union, unionBy, unionWith, uniq, uniqBy, uniqWith, unzip, unzipWith, upperCase, upperFirst, windowed, withTimeout, without, words, xor, xorBy, xorWith, zip, zipObject, zipWith };

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 };