es-toolkit 1.50.0 → 1.51.0-dev.2069

package/dist/object/index.d.mts

@@ -1,11 +1,14 @@
 import { clone } from "./clone.mjs";
 import { cloneDeep } from "./cloneDeep.mjs";
 import { cloneDeepWith } from "./cloneDeepWith.mjs";
+import { deepFreeze } from "./deepFreeze.mjs";
 import { findKey } from "./findKey.mjs";
 import { flattenObject } from "./flattenObject.mjs";
 import { invert } from "./invert.mjs";
 import { mapKeys } from "./mapKeys.mjs";
+import { mapKeysAsync } from "./mapKeysAsync.mjs";
 import { mapValues } from "./mapValues.mjs";
+import { mapValuesAsync } from "./mapValuesAsync.mjs";
 import { merge } from "./merge.mjs";
 import { mergeWith } from "./mergeWith.mjs";
 import { omit } from "./omit.mjs";
@@ -14,6 +17,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, deepFreeze, findKey, flattenObject, invert, mapKeys, mapKeysAsync, mapValues, mapValuesAsync, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toConstantCaseKeys, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys };

package/dist/object/index.d.ts

@@ -1,11 +1,14 @@
 import { clone } from "./clone.js";
 import { cloneDeep } from "./cloneDeep.js";
 import { cloneDeepWith } from "./cloneDeepWith.js";
+import { deepFreeze } from "./deepFreeze.js";
 import { findKey } from "./findKey.js";
 import { flattenObject } from "./flattenObject.js";
 import { invert } from "./invert.js";
 import { mapKeys } from "./mapKeys.js";
+import { mapKeysAsync } from "./mapKeysAsync.js";
 import { mapValues } from "./mapValues.js";
+import { mapValuesAsync } from "./mapValuesAsync.js";
 import { merge } from "./merge.js";
 import { mergeWith } from "./mergeWith.js";
 import { omit } from "./omit.js";
@@ -14,6 +17,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, deepFreeze, findKey, flattenObject, invert, mapKeys, mapKeysAsync, mapValues, mapValuesAsync, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toConstantCaseKeys, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys };

package/dist/object/index.js

@@ -2,11 +2,14 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_clone = require("./clone.js");
 const require_cloneDeepWith = require("./cloneDeepWith.js");
 const require_cloneDeep = require("./cloneDeep.js");
+const require_deepFreeze = require("./deepFreeze.js");
 const require_findKey = require("./findKey.js");
 const require_flattenObject = require("./flattenObject.js");
 const require_invert = require("./invert.js");
 const require_mapKeys = require("./mapKeys.js");
+const require_mapKeysAsync = require("./mapKeysAsync.js");
 const require_mapValues = require("./mapValues.js");
+const require_mapValuesAsync = require("./mapValuesAsync.js");
 const require_merge = require("./merge.js");
 const require_mergeWith = require("./mergeWith.js");
 const require_omit = require("./omit.js");
@@ -15,16 +18,22 @@ 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;
 exports.cloneDeepWith = require_cloneDeepWith.cloneDeepWith;
+exports.deepFreeze = require_deepFreeze.deepFreeze;
 exports.findKey = require_findKey.findKey;
 exports.flattenObject = require_flattenObject.flattenObject;
 exports.invert = require_invert.invert;
 exports.mapKeys = require_mapKeys.mapKeys;
+exports.mapKeysAsync = require_mapKeysAsync.mapKeysAsync;
 exports.mapValues = require_mapValues.mapValues;
+exports.mapValuesAsync = require_mapValuesAsync.mapValuesAsync;
 exports.merge = require_merge.merge;
 exports.mergeWith = require_mergeWith.mergeWith;
 exports.omit = require_omit.omit;
@@ -33,5 +42,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

@@ -1,11 +1,14 @@
 import { clone } from "./clone.mjs";
 import { cloneDeepWith } from "./cloneDeepWith.mjs";
 import { cloneDeep } from "./cloneDeep.mjs";
+import { deepFreeze } from "./deepFreeze.mjs";
 import { findKey } from "./findKey.mjs";
 import { flattenObject } from "./flattenObject.mjs";
 import { invert } from "./invert.mjs";
 import { mapKeys } from "./mapKeys.mjs";
+import { mapKeysAsync } from "./mapKeysAsync.mjs";
 import { mapValues } from "./mapValues.mjs";
+import { mapValuesAsync } from "./mapValuesAsync.mjs";
 import { merge } from "./merge.mjs";
 import { mergeWith } from "./mergeWith.mjs";
 import { omit } from "./omit.mjs";
@@ -14,6 +17,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, deepFreeze, findKey, flattenObject, invert, mapKeys, mapKeysAsync, mapValues, mapValuesAsync, merge, mergeWith, omit, omitBy, pick, pickBy, sortKeys, toCamelCaseKeys, toConstantCaseKeys, toKebabCaseKeys, toMerged, toPascalCaseKeys, toSnakeCaseKeys };

package/dist/object/mapKeysAsync.d.mts

@@ -0,0 +1,25 @@
+//#region src/object/mapKeysAsync.d.ts
+interface MapKeysAsyncOptions {
+  concurrency?: number;
+}
+/**
+ * Creates a new object with the same values as the given object, but with keys generated
+ * by running each own enumerable property of the object through the async iteratee function.
+ *
+ * @template T - The type of the object.
+ * @template K - The type of the new keys generated by the iteratee function.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {(value: T[keyof T], key: keyof T, object: T) => Promise<K>} getNewKey - The async function invoked per own enumerable property.
+ * @param {MapKeysAsyncOptions} [options] Optional configuration object.
+ * @returns {Promise<Record<K, T[keyof T]>>} - A promise that resolves to the new mapped object.
+ *
+ * @example
+ * // Example usage:
+ * const obj = { a: 1, b: 2 };
+ * const result = await mapKeysAsync(obj, async (value, key) => key + value);
+ * console.log(result); // { a1: 1, b2: 2 }
+ */
+declare function mapKeysAsync<T extends Record<PropertyKey, any>, K extends PropertyKey>(object: T, getNewKey: (value: T[keyof T], key: keyof T, object: T) => Promise<K>, options?: MapKeysAsyncOptions): Promise<Record<K, T[keyof T]>>;
+//#endregion
+export { mapKeysAsync };

package/dist/object/mapKeysAsync.d.ts

@@ -0,0 +1,25 @@
+//#region src/object/mapKeysAsync.d.ts
+interface MapKeysAsyncOptions {
+  concurrency?: number;
+}
+/**
+ * Creates a new object with the same values as the given object, but with keys generated
+ * by running each own enumerable property of the object through the async iteratee function.
+ *
+ * @template T - The type of the object.
+ * @template K - The type of the new keys generated by the iteratee function.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {(value: T[keyof T], key: keyof T, object: T) => Promise<K>} getNewKey - The async function invoked per own enumerable property.
+ * @param {MapKeysAsyncOptions} [options] Optional configuration object.
+ * @returns {Promise<Record<K, T[keyof T]>>} - A promise that resolves to the new mapped object.
+ *
+ * @example
+ * // Example usage:
+ * const obj = { a: 1, b: 2 };
+ * const result = await mapKeysAsync(obj, async (value, key) => key + value);
+ * console.log(result); // { a1: 1, b2: 2 }
+ */
+declare function mapKeysAsync<T extends Record<PropertyKey, any>, K extends PropertyKey>(object: T, getNewKey: (value: T[keyof T], key: keyof T, object: T) => Promise<K>, options?: MapKeysAsyncOptions): Promise<Record<K, T[keyof T]>>;
+//#endregion
+export { mapKeysAsync };

package/dist/object/mapKeysAsync.js

@@ -0,0 +1,32 @@
+const require_limitAsync = require("../promise/limitAsync.js");
+//#region src/object/mapKeysAsync.ts
+/**
+* Creates a new object with the same values as the given object, but with keys generated
+* by running each own enumerable property of the object through the async iteratee function.
+*
+* @template T - The type of the object.
+* @template K - The type of the new keys generated by the iteratee function.
+*
+* @param {T} object - The object to iterate over.
+* @param {(value: T[keyof T], key: keyof T, object: T) => Promise<K>} getNewKey - The async function invoked per own enumerable property.
+* @param {MapKeysAsyncOptions} [options] Optional configuration object.
+* @returns {Promise<Record<K, T[keyof T]>>} - A promise that resolves to the new mapped object.
+*
+* @example
+* // Example usage:
+* const obj = { a: 1, b: 2 };
+* const result = await mapKeysAsync(obj, async (value, key) => key + value);
+* console.log(result); // { a1: 1, b2: 2 }
+*/
+async function mapKeysAsync(object, getNewKey, options) {
+	const result = {};
+	const keys = Object.keys(object);
+	if (options?.concurrency) getNewKey = require_limitAsync.limitAsync(getNewKey, options.concurrency);
+	await Promise.all(keys.map(async (key) => {
+		const value = object[key];
+		result[await getNewKey(value, key, object)] = value;
+	}));
+	return result;
+}
+//#endregion
+exports.mapKeysAsync = mapKeysAsync;

package/dist/object/mapKeysAsync.mjs

@@ -0,0 +1,32 @@
+import { limitAsync } from "../promise/limitAsync.mjs";
+//#region src/object/mapKeysAsync.ts
+/**
+* Creates a new object with the same values as the given object, but with keys generated
+* by running each own enumerable property of the object through the async iteratee function.
+*
+* @template T - The type of the object.
+* @template K - The type of the new keys generated by the iteratee function.
+*
+* @param {T} object - The object to iterate over.
+* @param {(value: T[keyof T], key: keyof T, object: T) => Promise<K>} getNewKey - The async function invoked per own enumerable property.
+* @param {MapKeysAsyncOptions} [options] Optional configuration object.
+* @returns {Promise<Record<K, T[keyof T]>>} - A promise that resolves to the new mapped object.
+*
+* @example
+* // Example usage:
+* const obj = { a: 1, b: 2 };
+* const result = await mapKeysAsync(obj, async (value, key) => key + value);
+* console.log(result); // { a1: 1, b2: 2 }
+*/
+async function mapKeysAsync(object, getNewKey, options) {
+	const result = {};
+	const keys = Object.keys(object);
+	if (options?.concurrency) getNewKey = limitAsync(getNewKey, options.concurrency);
+	await Promise.all(keys.map(async (key) => {
+		const value = object[key];
+		result[await getNewKey(value, key, object)] = value;
+	}));
+	return result;
+}
+//#endregion
+export { mapKeysAsync };

package/dist/object/mapValuesAsync.d.mts

@@ -0,0 +1,26 @@
+//#region src/object/mapValuesAsync.d.ts
+interface MapValuesAsyncOptions {
+  concurrency?: number;
+}
+/**
+ * Creates a new object with the same keys as the given object, but with values generated
+ * by running each own enumerable property of the object through the async iteratee function.
+ *
+ * @template T - The type of the object.
+ * @template K - The type of the keys in the object.
+ * @template V - The type of the new values generated by the async iteratee function.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {(value: T[K], key: K, object: T) => Promise<V>} getNewValue - The async function invoked per own enumerable property.
+ * @param {MapValuesAsyncOptions} [options] Optional configuration object.
+ * @returns {Promise<Record<K, V>>} - A promise that resolves to the new mapped object.
+ *
+ * @example
+ * // Example usage:
+ * const obj = { a: 1, b: 2 };
+ * const result = await mapValuesAsync(obj, async (value) => value * 2);
+ * console.log(result); // { a: 2, b: 4 }
+ */
+declare function mapValuesAsync<T extends object, K extends keyof T, V>(object: T, getNewValue: (value: T[K], key: K, object: T) => Promise<V>, options?: MapValuesAsyncOptions): Promise<Record<K, V>>;
+//#endregion
+export { mapValuesAsync };

package/dist/object/mapValuesAsync.d.ts

@@ -0,0 +1,26 @@
+//#region src/object/mapValuesAsync.d.ts
+interface MapValuesAsyncOptions {
+  concurrency?: number;
+}
+/**
+ * Creates a new object with the same keys as the given object, but with values generated
+ * by running each own enumerable property of the object through the async iteratee function.
+ *
+ * @template T - The type of the object.
+ * @template K - The type of the keys in the object.
+ * @template V - The type of the new values generated by the async iteratee function.
+ *
+ * @param {T} object - The object to iterate over.
+ * @param {(value: T[K], key: K, object: T) => Promise<V>} getNewValue - The async function invoked per own enumerable property.
+ * @param {MapValuesAsyncOptions} [options] Optional configuration object.
+ * @returns {Promise<Record<K, V>>} - A promise that resolves to the new mapped object.
+ *
+ * @example
+ * // Example usage:
+ * const obj = { a: 1, b: 2 };
+ * const result = await mapValuesAsync(obj, async (value) => value * 2);
+ * console.log(result); // { a: 2, b: 4 }
+ */
+declare function mapValuesAsync<T extends object, K extends keyof T, V>(object: T, getNewValue: (value: T[K], key: K, object: T) => Promise<V>, options?: MapValuesAsyncOptions): Promise<Record<K, V>>;
+//#endregion
+export { mapValuesAsync };

package/dist/object/mapValuesAsync.js

@@ -0,0 +1,32 @@
+const require_limitAsync = require("../promise/limitAsync.js");
+//#region src/object/mapValuesAsync.ts
+/**
+* Creates a new object with the same keys as the given object, but with values generated
+* by running each own enumerable property of the object through the async iteratee function.
+*
+* @template T - The type of the object.
+* @template K - The type of the keys in the object.
+* @template V - The type of the new values generated by the async iteratee function.
+*
+* @param {T} object - The object to iterate over.
+* @param {(value: T[K], key: K, object: T) => Promise<V>} getNewValue - The async function invoked per own enumerable property.
+* @param {MapValuesAsyncOptions} [options] Optional configuration object.
+* @returns {Promise<Record<K, V>>} - A promise that resolves to the new mapped object.
+*
+* @example
+* // Example usage:
+* const obj = { a: 1, b: 2 };
+* const result = await mapValuesAsync(obj, async (value) => value * 2);
+* console.log(result); // { a: 2, b: 4 }
+*/
+async function mapValuesAsync(object, getNewValue, options) {
+	const result = {};
+	const keys = Object.keys(object);
+	if (options?.concurrency) getNewValue = require_limitAsync.limitAsync(getNewValue, options.concurrency);
+	await Promise.all(keys.map(async (key) => {
+		result[key] = await getNewValue(object[key], key, object);
+	}));
+	return result;
+}
+//#endregion
+exports.mapValuesAsync = mapValuesAsync;

package/dist/object/mapValuesAsync.mjs

@@ -0,0 +1,32 @@
+import { limitAsync } from "../promise/limitAsync.mjs";
+//#region src/object/mapValuesAsync.ts
+/**
+* Creates a new object with the same keys as the given object, but with values generated
+* by running each own enumerable property of the object through the async iteratee function.
+*
+* @template T - The type of the object.
+* @template K - The type of the keys in the object.
+* @template V - The type of the new values generated by the async iteratee function.
+*
+* @param {T} object - The object to iterate over.
+* @param {(value: T[K], key: K, object: T) => Promise<V>} getNewValue - The async function invoked per own enumerable property.
+* @param {MapValuesAsyncOptions} [options] Optional configuration object.
+* @returns {Promise<Record<K, V>>} - A promise that resolves to the new mapped object.
+*
+* @example
+* // Example usage:
+* const obj = { a: 1, b: 2 };
+* const result = await mapValuesAsync(obj, async (value) => value * 2);
+* console.log(result); // { a: 2, b: 4 }
+*/
+async function mapValuesAsync(object, getNewValue, options) {
+	const result = {};
+	const keys = Object.keys(object);
+	if (options?.concurrency) getNewValue = limitAsync(getNewValue, options.concurrency);
+	await Promise.all(keys.map(async (key) => {
+		result[key] = await getNewValue(object[key], key, object);
+	}));
+	return result;
+}
+//#endregion
+export { mapValuesAsync };

package/dist/object/merge.js

@@ -1,4 +1,5 @@
 const require_isPlainObject = require("../predicate/isPlainObject.js");
+const require_isMergeableValue = require("../_internal/isMergeableValue.js");
 const require_isUnsafeProperty = require("../_internal/isUnsafeProperty.js");
 //#region src/object/merge.ts
 /**
@@ -48,15 +49,12 @@ function merge(target, source) {
 		if (require_isUnsafeProperty.isUnsafeProperty(key)) continue;
 		const sourceValue = source[key];
 		const targetValue = target[key];
-		if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) target[key] = merge(targetValue, sourceValue);
+		if (require_isMergeableValue.isMergeableValue(sourceValue) && require_isMergeableValue.isMergeableValue(targetValue)) target[key] = merge(targetValue, sourceValue);
 		else if (Array.isArray(sourceValue)) target[key] = merge([], sourceValue);
 		else if (require_isPlainObject.isPlainObject(sourceValue)) target[key] = merge({}, sourceValue);
 		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
 	}
 	return target;
 }
-function isMergeableValue(value) {
-	return require_isPlainObject.isPlainObject(value) || Array.isArray(value);
-}
 //#endregion
 exports.merge = merge;

package/dist/object/merge.mjs

@@ -1,4 +1,5 @@
 import { isPlainObject } from "../predicate/isPlainObject.mjs";
+import { isMergeableValue } from "../_internal/isMergeableValue.mjs";
 import { isUnsafeProperty } from "../_internal/isUnsafeProperty.mjs";
 //#region src/object/merge.ts
 /**
@@ -55,8 +56,5 @@ function merge(target, source) {
 	}
 	return target;
 }
-function isMergeableValue(value) {
-	return isPlainObject(value) || Array.isArray(value);
-}
 //#endregion
 export { merge };

package/dist/object/mergeWith.js

@@ -1,4 +1,5 @@
 const require_isPlainObject = require("../predicate/isPlainObject.js");
+const require_isMergeableValue = require("../_internal/isMergeableValue.js");
 const require_isUnsafeProperty = require("../_internal/isUnsafeProperty.js");
 //#region src/object/mergeWith.ts
 /**
@@ -58,10 +59,9 @@ function mergeWith(target, source, merge) {
 		const targetValue = target[key];
 		const merged = merge(targetValue, sourceValue, key, target, source);
 		if (merged !== void 0) target[key] = merged;
-		else if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
-		else target[key] = mergeWith([], sourceValue, merge);
-		else if (require_isPlainObject.isPlainObject(sourceValue)) if (require_isPlainObject.isPlainObject(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
-		else target[key] = mergeWith({}, sourceValue, merge);
+		else if (require_isMergeableValue.isMergeableValue(sourceValue) && require_isMergeableValue.isMergeableValue(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
+		else if (Array.isArray(sourceValue)) target[key] = mergeWith([], sourceValue, merge);
+		else if (require_isPlainObject.isPlainObject(sourceValue)) target[key] = mergeWith({}, sourceValue, merge);
 		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
 	}
 	return target;

package/dist/object/mergeWith.mjs

@@ -1,4 +1,5 @@
 import { isPlainObject } from "../predicate/isPlainObject.mjs";
+import { isMergeableValue } from "../_internal/isMergeableValue.mjs";
 import { isUnsafeProperty } from "../_internal/isUnsafeProperty.mjs";
 //#region src/object/mergeWith.ts
 /**
@@ -58,10 +59,9 @@ function mergeWith(target, source, merge) {
 		const targetValue = target[key];
 		const merged = merge(targetValue, sourceValue, key, target, source);
 		if (merged !== void 0) target[key] = merged;
-		else if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
-		else target[key] = mergeWith([], sourceValue, merge);
-		else if (isPlainObject(sourceValue)) if (isPlainObject(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
-		else target[key] = mergeWith({}, sourceValue, merge);
+		else if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
+		else if (Array.isArray(sourceValue)) target[key] = mergeWith([], sourceValue, merge);
+		else if (isPlainObject(sourceValue)) target[key] = mergeWith({}, sourceValue, merge);
 		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
 	}
 	return target;

package/dist/object/toCamelCaseKeys.d.mts

@@ -1,10 +1,6 @@
+import { ToCamelCaseKeys } from "../types/ToCamelCaseKeys.mjs";
+
 //#region src/object/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>;
-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 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;
 /**
  * Creates a new object composed of the properties with keys converted to camelCase.
  *

package/dist/object/toCamelCaseKeys.d.ts

@@ -1,10 +1,6 @@
+import { ToCamelCaseKeys } from "../types/ToCamelCaseKeys.js";
+
 //#region src/object/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>;
-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 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;
 /**
  * Creates a new object composed of the properties with keys converted to camelCase.
  *

package/dist/object/toConstantCaseKeys.d.mts

@@ -0,0 +1,52 @@
+import { ToConstantCaseKeys } from "../types/ToConstantCaseKeys.mjs";
+
+//#region src/object/toConstantCaseKeys.d.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'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toConstantCaseKeys<T>(obj: T): ToConstantCaseKeys<T>;
+//#endregion
+export { toConstantCaseKeys };

package/dist/object/toConstantCaseKeys.d.ts

@@ -0,0 +1,52 @@
+import { ToConstantCaseKeys } from "../types/ToConstantCaseKeys.js";
+
+//#region src/object/toConstantCaseKeys.d.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'
+ * //     }
+ * //   }
+ * // }
+ */
+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;