es-toolkit 1.50.0 → 1.51.0-dev.2065

package/dist/object/deepFreeze.d.ts

@@ -0,0 +1,20 @@
+//#region src/object/deepFreeze.d.ts
+/**
+ * Deeply freezes an object, making it and all nested objects immutable.
+ *
+ * Unlike `Object.freeze`, which only freezes the immediate properties of an object,
+ * `deepFreeze` recursively freezes all nested objects and arrays.
+ *
+ * @template T - The type of the object.
+ * @param {T} obj - The object to deeply freeze.
+ * @returns {T} The deeply frozen object.
+ *
+ * @example
+ * const frozen = deepFreeze({ user: { name: "Alex", age: 20 } });
+ *
+ * frozen.user = {}; // TypeError in strict mode
+ * frozen.user.age = 22; // TypeError in strict mode
+ */
+declare function deepFreeze<T>(obj: T): T;
+//#endregion
+export { deepFreeze };

package/dist/object/deepFreeze.js

@@ -0,0 +1,29 @@
+//#region src/object/deepFreeze.ts
+/**
+* Deeply freezes an object, making it and all nested objects immutable.
+*
+* Unlike `Object.freeze`, which only freezes the immediate properties of an object,
+* `deepFreeze` recursively freezes all nested objects and arrays.
+*
+* @template T - The type of the object.
+* @param {T} obj - The object to deeply freeze.
+* @returns {T} The deeply frozen object.
+*
+* @example
+* const frozen = deepFreeze({ user: { name: "Alex", age: 20 } });
+*
+* frozen.user = {}; // TypeError in strict mode
+* frozen.user.age = 22; // TypeError in strict mode
+*/
+function deepFreeze(obj) {
+	if (obj === null || typeof obj !== "object") return obj;
+	Object.freeze(obj);
+	const keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; i++) {
+		const value = obj[keys[i]];
+		if (value !== null && typeof value === "object" && !Object.isFrozen(value)) deepFreeze(value);
+	}
+	return obj;
+}
+//#endregion
+exports.deepFreeze = deepFreeze;

package/dist/object/deepFreeze.mjs

@@ -0,0 +1,29 @@
+//#region src/object/deepFreeze.ts
+/**
+* Deeply freezes an object, making it and all nested objects immutable.
+*
+* Unlike `Object.freeze`, which only freezes the immediate properties of an object,
+* `deepFreeze` recursively freezes all nested objects and arrays.
+*
+* @template T - The type of the object.
+* @param {T} obj - The object to deeply freeze.
+* @returns {T} The deeply frozen object.
+*
+* @example
+* const frozen = deepFreeze({ user: { name: "Alex", age: 20 } });
+*
+* frozen.user = {}; // TypeError in strict mode
+* frozen.user.age = 22; // TypeError in strict mode
+*/
+function deepFreeze(obj) {
+	if (obj === null || typeof obj !== "object") return obj;
+	Object.freeze(obj);
+	const keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; i++) {
+		const value = obj[keys[i]];
+		if (value !== null && typeof value === "object" && !Object.isFrozen(value)) deepFreeze(value);
+	}
+	return obj;
+}
+//#endregion
+export { deepFreeze };

package/dist/object/flattenObject.d.mts

@@ -5,12 +5,18 @@ interface FlattenObjectOptions {
    * @default '.'
    */
   delimiter?: string;
+  /**
+   * If true, arrays are kept as values instead of being flattened.
+   * @default false
+   */
+  preserveArrays?: boolean;
 }
 /**
  * Flattens a nested object into a single level object with delimiter-separated keys.
  *
  * @param object - The object to flatten.
  * @param [options.delimiter='.'] - The delimiter to use between nested keys.
+ * @param [options.preserveArrays=false] - If true, arrays are kept as values instead of being flattened.
  * @returns The flattened object.
  *
  * @example
@@ -31,9 +37,18 @@ interface FlattenObjectOptions {
  * //   'd.0': 2,
  * //   'd.1': 3
  * // }
+ *
+ * const preserved = flattenObject(nestedObject, { preserveArrays: true });
+ * console.log(preserved);
+ * // Output:
+ * // {
+ * //   'a.b.c': 1,
+ * //   'd': [2, 3]
+ * // }
  */
 declare function flattenObject(object: object, {
-  delimiter
+  delimiter,
+  preserveArrays
 }?: FlattenObjectOptions): Record<string, any>;
 //#endregion
 export { flattenObject };

package/dist/object/flattenObject.d.ts

@@ -5,12 +5,18 @@ interface FlattenObjectOptions {
    * @default '.'
    */
   delimiter?: string;
+  /**
+   * If true, arrays are kept as values instead of being flattened.
+   * @default false
+   */
+  preserveArrays?: boolean;
 }
 /**
  * Flattens a nested object into a single level object with delimiter-separated keys.
  *
  * @param object - The object to flatten.
  * @param [options.delimiter='.'] - The delimiter to use between nested keys.
+ * @param [options.preserveArrays=false] - If true, arrays are kept as values instead of being flattened.
  * @returns The flattened object.
  *
  * @example
@@ -31,9 +37,18 @@ interface FlattenObjectOptions {
  * //   'd.0': 2,
  * //   'd.1': 3
  * // }
+ *
+ * const preserved = flattenObject(nestedObject, { preserveArrays: true });
+ * console.log(preserved);
+ * // Output:
+ * // {
+ * //   'a.b.c': 1,
+ * //   'd': [2, 3]
+ * // }
  */
 declare function flattenObject(object: object, {
-  delimiter
+  delimiter,
+  preserveArrays
 }?: FlattenObjectOptions): Record<string, any>;
 //#endregion
 export { flattenObject };

package/dist/object/flattenObject.js

@@ -5,6 +5,7 @@ const require_isPlainObject = require("../predicate/isPlainObject.js");
 *
 * @param object - The object to flatten.
 * @param [options.delimiter='.'] - The delimiter to use between nested keys.
+* @param [options.preserveArrays=false] - If true, arrays are kept as values instead of being flattened.
 * @returns The flattened object.
 *
 * @example
@@ -25,11 +26,19 @@ const require_isPlainObject = require("../predicate/isPlainObject.js");
 * //   'd.0': 2,
 * //   'd.1': 3
 * // }
+*
+* const preserved = flattenObject(nestedObject, { preserveArrays: true });
+* console.log(preserved);
+* // Output:
+* // {
+* //   'a.b.c': 1,
+* //   'd': [2, 3]
+* // }
 */
-function flattenObject(object, { delimiter = "." } = {}) {
-	return flattenObjectImpl(object, "", delimiter);
+function flattenObject(object, { delimiter = ".", preserveArrays = false } = {}) {
+	return flattenObjectImpl(object, "", delimiter, preserveArrays);
 }
-function flattenObjectImpl(object, prefix, delimiter) {
+function flattenObjectImpl(object, prefix, delimiter, preserveArrays) {
 	const result = {};
 	const keys = Object.keys(object);
 	for (let i = 0; i < keys.length; i++) {
@@ -37,11 +46,11 @@ function flattenObjectImpl(object, prefix, delimiter) {
 		const value = object[key];
 		const prefixedKey = prefix ? `${prefix}${delimiter}${key}` : key;
 		if (require_isPlainObject.isPlainObject(value) && Object.keys(value).length > 0) {
-			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter, preserveArrays));
 			continue;
 		}
-		if (Array.isArray(value) && value.length > 0) {
-			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+		if (Array.isArray(value) && !preserveArrays && value.length > 0) {
+			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter, preserveArrays));
 			continue;
 		}
 		result[prefixedKey] = value;

package/dist/object/flattenObject.mjs

@@ -5,6 +5,7 @@ import { isPlainObject } from "../predicate/isPlainObject.mjs";
 *
 * @param object - The object to flatten.
 * @param [options.delimiter='.'] - The delimiter to use between nested keys.
+* @param [options.preserveArrays=false] - If true, arrays are kept as values instead of being flattened.
 * @returns The flattened object.
 *
 * @example
@@ -25,11 +26,19 @@ import { isPlainObject } from "../predicate/isPlainObject.mjs";
 * //   'd.0': 2,
 * //   'd.1': 3
 * // }
+*
+* const preserved = flattenObject(nestedObject, { preserveArrays: true });
+* console.log(preserved);
+* // Output:
+* // {
+* //   'a.b.c': 1,
+* //   'd': [2, 3]
+* // }
 */
-function flattenObject(object, { delimiter = "." } = {}) {
-	return flattenObjectImpl(object, "", delimiter);
+function flattenObject(object, { delimiter = ".", preserveArrays = false } = {}) {
+	return flattenObjectImpl(object, "", delimiter, preserveArrays);
 }
-function flattenObjectImpl(object, prefix, delimiter) {
+function flattenObjectImpl(object, prefix, delimiter, preserveArrays) {
 	const result = {};
 	const keys = Object.keys(object);
 	for (let i = 0; i < keys.length; i++) {
@@ -37,11 +46,11 @@ function flattenObjectImpl(object, prefix, delimiter) {
 		const value = object[key];
 		const prefixedKey = prefix ? `${prefix}${delimiter}${key}` : key;
 		if (isPlainObject(value) && Object.keys(value).length > 0) {
-			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter, preserveArrays));
 			continue;
 		}
-		if (Array.isArray(value) && value.length > 0) {
-			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter));
+		if (Array.isArray(value) && !preserveArrays && value.length > 0) {
+			Object.assign(result, flattenObjectImpl(value, prefixedKey, delimiter, preserveArrays));
 			continue;
 		}
 		result[prefixedKey] = value;

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