@pixpilot/object 2.0.0 → 2.1.1

package/dist/_virtual/rolldown_runtime.cjs

@@ -1 +1,25 @@
-var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));exports.__toESM=s;
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/clean-object.cjs

@@ -0,0 +1,60 @@
+const require_type_guards = require('./type-guards.cjs');
+
+//#region src/clean-object.ts
+function resolveOptions(options) {
+	return {
+		cleanKeys: options?.cleanKeys ?? [],
+		cleanValues: options?.cleanValues ?? [],
+		emptyArrays: options?.emptyArrays ?? true,
+		emptyObjects: options?.emptyObjects ?? true,
+		emptyStrings: options?.emptyStrings ?? true,
+		NaNValues: options?.NaNValues ?? false,
+		nullValues: options?.nullValues ?? true,
+		undefinedValues: options?.undefinedValues ?? true,
+		shouldRemove: options?.shouldRemove,
+		transform: options?.transform
+	};
+}
+function isCleanable(value) {
+	return (Array.isArray(value) || require_type_guards.isPlainObject(value)) && !(value instanceof Date);
+}
+function shouldSkipValue(value, options) {
+	if (options.cleanValues.includes(value)) return true;
+	if (options.emptyObjects && require_type_guards.isPlainObject(value) && require_type_guards.isEmptyObject(value)) return true;
+	if (options.emptyArrays && Array.isArray(value) && value.length === 0) return true;
+	if (options.emptyStrings && value === "") return true;
+	if (options.NaNValues && typeof value === "number" && Number.isNaN(value)) return true;
+	if (options.nullValues && value === null) return true;
+	if (options.undefinedValues && value === void 0) return true;
+	return false;
+}
+function cleanDeep(value, options) {
+	if (Array.isArray(value)) {
+		const result$1 = [];
+		for (let index = 0; index < value.length; index += 1) {
+			const key = String(index);
+			if (!options.cleanKeys.includes(key)) {
+				const transformed = options.transform ? options.transform(key, value[index], value) : value[index];
+				const cleaned = isCleanable(transformed) ? cleanDeep(transformed, options) : transformed;
+				if (!((options.shouldRemove ? options.shouldRemove(key, cleaned, value) : false) || shouldSkipValue(cleaned, options))) result$1.push(cleaned);
+			}
+		}
+		return result$1;
+	}
+	const prototype = Object.getPrototypeOf(value);
+	const result = Object.create(prototype);
+	for (const [key, originalValue] of Object.entries(value)) if (!options.cleanKeys.includes(key)) {
+		const transformed = options.transform ? options.transform(key, originalValue, value) : originalValue;
+		const cleaned = isCleanable(transformed) ? cleanDeep(transformed, options) : transformed;
+		if (!((options.shouldRemove ? options.shouldRemove(key, cleaned, value) : false) || shouldSkipValue(cleaned, options))) result[key] = cleaned;
+	}
+	return result;
+}
+function cleanObject(value, options) {
+	const resolvedOptions = resolveOptions(options);
+	if (!isCleanable(value)) return value;
+	return cleanDeep(value, resolvedOptions);
+}
+
+//#endregion
+exports.cleanObject = cleanObject;

package/dist/clean-object.d.cts

@@ -0,0 +1,19 @@
+//#region src/clean-object.d.ts
+/**
+ * Inspired by https://github.com/nunofgs/clean-deep
+ */
+interface CleanOptions {
+  cleanKeys?: readonly string[];
+  cleanValues?: readonly unknown[];
+  emptyArrays?: boolean;
+  emptyObjects?: boolean;
+  emptyStrings?: boolean;
+  NaNValues?: boolean;
+  nullValues?: boolean;
+  undefinedValues?: boolean;
+  shouldRemove?: (key: string, value: unknown, base?: unknown) => boolean;
+  transform?: (key: string, value: unknown, base?: unknown) => unknown;
+}
+declare function cleanObject<T>(value: T, options?: CleanOptions): T;
+//#endregion
+export { CleanOptions, cleanObject };

package/dist/clean-object.d.ts

@@ -0,0 +1,19 @@
+//#region src/clean-object.d.ts
+/**
+ * Inspired by https://github.com/nunofgs/clean-deep
+ */
+interface CleanOptions {
+  cleanKeys?: readonly string[];
+  cleanValues?: readonly unknown[];
+  emptyArrays?: boolean;
+  emptyObjects?: boolean;
+  emptyStrings?: boolean;
+  NaNValues?: boolean;
+  nullValues?: boolean;
+  undefinedValues?: boolean;
+  shouldRemove?: (key: string, value: unknown, base?: unknown) => boolean;
+  transform?: (key: string, value: unknown, base?: unknown) => unknown;
+}
+declare function cleanObject<T>(value: T, options?: CleanOptions): T;
+//#endregion
+export { CleanOptions, cleanObject };

package/dist/clean-object.js

@@ -0,0 +1,60 @@
+import { isEmptyObject, isPlainObject } from "./type-guards.js";
+
+//#region src/clean-object.ts
+function resolveOptions(options) {
+	return {
+		cleanKeys: options?.cleanKeys ?? [],
+		cleanValues: options?.cleanValues ?? [],
+		emptyArrays: options?.emptyArrays ?? true,
+		emptyObjects: options?.emptyObjects ?? true,
+		emptyStrings: options?.emptyStrings ?? true,
+		NaNValues: options?.NaNValues ?? false,
+		nullValues: options?.nullValues ?? true,
+		undefinedValues: options?.undefinedValues ?? true,
+		shouldRemove: options?.shouldRemove,
+		transform: options?.transform
+	};
+}
+function isCleanable(value) {
+	return (Array.isArray(value) || isPlainObject(value)) && !(value instanceof Date);
+}
+function shouldSkipValue(value, options) {
+	if (options.cleanValues.includes(value)) return true;
+	if (options.emptyObjects && isPlainObject(value) && isEmptyObject(value)) return true;
+	if (options.emptyArrays && Array.isArray(value) && value.length === 0) return true;
+	if (options.emptyStrings && value === "") return true;
+	if (options.NaNValues && typeof value === "number" && Number.isNaN(value)) return true;
+	if (options.nullValues && value === null) return true;
+	if (options.undefinedValues && value === void 0) return true;
+	return false;
+}
+function cleanDeep(value, options) {
+	if (Array.isArray(value)) {
+		const result$1 = [];
+		for (let index = 0; index < value.length; index += 1) {
+			const key = String(index);
+			if (!options.cleanKeys.includes(key)) {
+				const transformed = options.transform ? options.transform(key, value[index], value) : value[index];
+				const cleaned = isCleanable(transformed) ? cleanDeep(transformed, options) : transformed;
+				if (!((options.shouldRemove ? options.shouldRemove(key, cleaned, value) : false) || shouldSkipValue(cleaned, options))) result$1.push(cleaned);
+			}
+		}
+		return result$1;
+	}
+	const prototype = Object.getPrototypeOf(value);
+	const result = Object.create(prototype);
+	for (const [key, originalValue] of Object.entries(value)) if (!options.cleanKeys.includes(key)) {
+		const transformed = options.transform ? options.transform(key, originalValue, value) : originalValue;
+		const cleaned = isCleanable(transformed) ? cleanDeep(transformed, options) : transformed;
+		if (!((options.shouldRemove ? options.shouldRemove(key, cleaned, value) : false) || shouldSkipValue(cleaned, options))) result[key] = cleaned;
+	}
+	return result;
+}
+function cleanObject(value, options) {
+	const resolvedOptions = resolveOptions(options);
+	if (!isCleanable(value)) return value;
+	return cleanDeep(value, resolvedOptions);
+}
+
+//#endregion
+export { cleanObject };

package/dist/deep-merge.cjs

@@ -1 +1,54 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`);let t=require(`@fastify/deepmerge`);t=e.__toESM(t);let n=null;function r(){return n||=(0,t.default)(),n}function i(...e){if(e.length===0)return{};if(e.length===1)return e[0]??{};let t={};for(let n of e)t=r()(t,n);return t}function a(e,t){return r()(e,t)}exports.deepMerge=a,exports.deepMergeMany=i;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let __fastify_deepmerge = require("@fastify/deepmerge");
+__fastify_deepmerge = require_rolldown_runtime.__toESM(__fastify_deepmerge);
+
+//#region src/deep-merge.ts
+let deepMergeInstance = null;
+function getDeepMerge() {
+	if (!deepMergeInstance) deepMergeInstance = (0, __fastify_deepmerge.default)();
+	return deepMergeInstance;
+}
+/**
+* Deep merge multiple objects.
+*
+* Uses @fastify/deepmerge to merge any number of objects into a single result.
+* Objects are merged from left to right, with later objects overriding earlier ones.
+*
+* @param objects - The objects to merge
+* @returns A new merged object
+*
+* @example
+* ```typescript
+* const obj1 = { a: 1, b: { c: 2 } };
+* const obj2 = { b: { d: 3 }, e: 4 };
+* const obj3 = { e: 5, f: 6 };
+* deepMergeMany(obj1, obj2, obj3); // { a: 1, b: { c: 2, d: 3 }, e: 5, f: 6 }
+* ```
+*/
+function deepMergeMany(...objects) {
+	if (objects.length === 0) return {};
+	if (objects.length === 1) return objects[0] ?? {};
+	let result = {};
+	for (const obj of objects) result = getDeepMerge()(result, obj);
+	return result;
+}
+/**
+* Re-export the configured deepmerge instance from @fastify/deepmerge.
+*
+* This provides direct access to the deepmerge function for advanced use cases,
+* allowing merging of multiple objects and custom options.
+*
+* @example
+* ```typescript
+* import { deepmerge } from '@pixpilot/object';
+* const result = deepmerge({ a: 1 }, { b: 2 }, { c: 3 });
+* // { a: 1, b: 2, c: 3 }
+* ```
+*/
+function deepMerge(target, source) {
+	return getDeepMerge()(target, source);
+}
+
+//#endregion
+exports.deepMerge = deepMerge;
+exports.deepMergeMany = deepMergeMany;

package/dist/deep-merge.js

@@ -1 +1,51 @@
-import e from"@fastify/deepmerge";let t=null;function n(){return t||=e(),t}function r(...e){if(e.length===0)return{};if(e.length===1)return e[0]??{};let t={};for(let r of e)t=n()(t,r);return t}function i(e,t){return n()(e,t)}export{i as deepMerge,r as deepMergeMany};
+import deepmerge from "@fastify/deepmerge";
+
+//#region src/deep-merge.ts
+let deepMergeInstance = null;
+function getDeepMerge() {
+	if (!deepMergeInstance) deepMergeInstance = deepmerge();
+	return deepMergeInstance;
+}
+/**
+* Deep merge multiple objects.
+*
+* Uses @fastify/deepmerge to merge any number of objects into a single result.
+* Objects are merged from left to right, with later objects overriding earlier ones.
+*
+* @param objects - The objects to merge
+* @returns A new merged object
+*
+* @example
+* ```typescript
+* const obj1 = { a: 1, b: { c: 2 } };
+* const obj2 = { b: { d: 3 }, e: 4 };
+* const obj3 = { e: 5, f: 6 };
+* deepMergeMany(obj1, obj2, obj3); // { a: 1, b: { c: 2, d: 3 }, e: 5, f: 6 }
+* ```
+*/
+function deepMergeMany(...objects) {
+	if (objects.length === 0) return {};
+	if (objects.length === 1) return objects[0] ?? {};
+	let result = {};
+	for (const obj of objects) result = getDeepMerge()(result, obj);
+	return result;
+}
+/**
+* Re-export the configured deepmerge instance from @fastify/deepmerge.
+*
+* This provides direct access to the deepmerge function for advanced use cases,
+* allowing merging of multiple objects and custom options.
+*
+* @example
+* ```typescript
+* import { deepmerge } from '@pixpilot/object';
+* const result = deepmerge({ a: 1 }, { b: 2 }, { c: 3 });
+* // { a: 1, b: 2, c: 3 }
+* ```
+*/
+function deepMerge(target, source) {
+	return getDeepMerge()(target, source);
+}
+
+//#endregion
+export { deepMerge, deepMergeMany };

package/dist/delete-object-property-by-path.cjs

@@ -1 +1,5 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`);let t=require(`dot-prop`);t=e.__toESM(t),exports.deleteObjectPropertyByPath=t.deleteProperty;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let dot_prop = require("dot-prop");
+dot_prop = require_rolldown_runtime.__toESM(dot_prop);
+
+exports.deleteObjectPropertyByPath = dot_prop.deleteProperty;

package/dist/delete-object-property-by-path.js

@@ -1 +1,3 @@
-import{deleteProperty as e}from"dot-prop";export{e as deleteObjectPropertyByPath};
+import { deleteProperty } from "dot-prop";
+
+export { deleteProperty as deleteObjectPropertyByPath };

package/dist/get-object-value-by-path.cjs

@@ -1 +1,5 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`);let t=require(`dot-prop`);t=e.__toESM(t),exports.getObjectValueByPath=t.getProperty;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let dot_prop = require("dot-prop");
+dot_prop = require_rolldown_runtime.__toESM(dot_prop);
+
+exports.getObjectValueByPath = dot_prop.getProperty;

package/dist/get-object-value-by-path.js

@@ -1 +1,3 @@
-import{getProperty as e}from"dot-prop";export{e as getObjectValueByPath};
+import { getProperty } from "dot-prop";
+
+export { getProperty as getObjectValueByPath };

package/dist/has-object-value-by-path.cjs

@@ -1 +1,5 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`);let t=require(`dot-prop`);t=e.__toESM(t),exports.hasObjectValueByPath=t.hasProperty;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let dot_prop = require("dot-prop");
+dot_prop = require_rolldown_runtime.__toESM(dot_prop);
+
+exports.hasObjectValueByPath = dot_prop.hasProperty;

package/dist/has-object-value-by-path.js

@@ -1 +1,3 @@
-import{hasProperty as e}from"dot-prop";export{e as hasObjectValueByPath};
+import { hasProperty } from "dot-prop";
+
+export { hasProperty as hasObjectValueByPath };

package/dist/index.cjs

@@ -1 +1,41 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`),t=require(`./deep-merge.cjs`);require(`./delete-object-property-by-path.cjs`),require(`./get-object-value-by-path.cjs`),require(`./has-object-value-by-path.cjs`);const n=require(`./keys-to-camel-case.cjs`),r=require(`./keys-to-snake-case.cjs`),i=require(`./manipulation.cjs`),a=require(`./set-object-value-by-path.cjs`),o=require(`./type-guards.cjs`);let s=require(`dot-prop`);s=e.__toESM(s),exports.deepClone=i.deepClone,exports.deepEqual=i.deepEqual,exports.deepMerge=t.deepMerge,exports.deepMergeMany=t.deepMergeMany,exports.deleteObjectPropertyByPath=s.deleteProperty,exports.deleteProperty=s.deleteProperty,exports.escapePath=s.escapePath,exports.flatKeys=i.flatKeys,exports.getObjectValueByPath=s.getProperty,exports.getProperty=s.getProperty,exports.hasObjectValueByPath=s.hasProperty,exports.hasProperty=s.hasProperty,exports.isEmptyObject=o.isEmptyObject,exports.isObject=o.isObject,exports.isPlainObject=o.isPlainObject,exports.keysToCamelCase=n.keysToCamelCase,exports.keysToSnakeCase=r.keysToSnakeCase,exports.mapKeys=i.mapKeys,exports.mapValues=i.mapValues,exports.omit=i.omit,exports.parsePath=s.parsePath,exports.pick=i.pick,exports.setObjectValueByPath=a.setObjectValueByPath,exports.setProperty=s.setProperty,exports.stringifyPath=s.stringifyPath,exports.unflatten=s.unflatten;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_type_guards = require('./type-guards.cjs');
+const require_clean_object = require('./clean-object.cjs');
+const require_deep_merge = require('./deep-merge.cjs');
+require('./delete-object-property-by-path.cjs');
+require('./get-object-value-by-path.cjs');
+require('./has-object-value-by-path.cjs');
+const require_keys_to_camel_case = require('./keys-to-camel-case.cjs');
+const require_keys_to_snake_case = require('./keys-to-snake-case.cjs');
+const require_manipulation = require('./manipulation.cjs');
+const require_set_object_value_by_path = require('./set-object-value-by-path.cjs');
+let dot_prop = require("dot-prop");
+dot_prop = require_rolldown_runtime.__toESM(dot_prop);
+
+exports.cleanObject = require_clean_object.cleanObject;
+exports.deepClone = require_manipulation.deepClone;
+exports.deepEqual = require_manipulation.deepEqual;
+exports.deepMerge = require_deep_merge.deepMerge;
+exports.deepMergeMany = require_deep_merge.deepMergeMany;
+exports.deleteObjectPropertyByPath = dot_prop.deleteProperty;
+exports.deleteProperty = dot_prop.deleteProperty;
+exports.escapePath = dot_prop.escapePath;
+exports.flatKeys = require_manipulation.flatKeys;
+exports.getObjectValueByPath = dot_prop.getProperty;
+exports.getProperty = dot_prop.getProperty;
+exports.hasObjectValueByPath = dot_prop.hasProperty;
+exports.hasProperty = dot_prop.hasProperty;
+exports.isEmptyObject = require_type_guards.isEmptyObject;
+exports.isObject = require_type_guards.isObject;
+exports.isPlainObject = require_type_guards.isPlainObject;
+exports.keysToCamelCase = require_keys_to_camel_case.keysToCamelCase;
+exports.keysToSnakeCase = require_keys_to_snake_case.keysToSnakeCase;
+exports.mapKeys = require_manipulation.mapKeys;
+exports.mapValues = require_manipulation.mapValues;
+exports.omit = require_manipulation.omit;
+exports.parsePath = dot_prop.parsePath;
+exports.pick = require_manipulation.pick;
+exports.setObjectValueByPath = require_set_object_value_by_path.setObjectValueByPath;
+exports.setProperty = dot_prop.setProperty;
+exports.stringifyPath = dot_prop.stringifyPath;
+exports.unflatten = dot_prop.unflatten;

package/dist/index.d.cts

@@ -1,3 +1,4 @@
+import { CleanOptions, cleanObject } from "./clean-object.cjs";
 import { deepMerge, deepMergeMany } from "./deep-merge.cjs";
 import { deleteObjectPropertyByPath as deleteProperty } from "./delete-object-property-by-path.cjs";
 import { getObjectValueByPath as getProperty } from "./get-object-value-by-path.cjs";
@@ -7,4 +8,4 @@ import { KeysToSnakeCase, ToSnakeCase, keysToSnakeCase } from "./keys-to-snake-c
 import { deepClone, deepEqual, deleteProperty as deleteProperty$1, escapePath, flatKeys, getProperty as getProperty$1, hasProperty as hasProperty$1, mapKeys, mapValues, omit, parsePath, pick, setProperty, stringifyPath, unflatten } from "./manipulation.cjs";
 import { setObjectValueByPath } from "./set-object-value-by-path.cjs";
 import { isEmptyObject, isObject, isPlainObject } from "./type-guards.cjs";
-export { KeysToCamelCase, KeysToSnakeCase, ToCamelCase, ToSnakeCase, deepClone, deepEqual, deepMerge, deepMergeMany, deleteProperty as deleteObjectPropertyByPath, deleteProperty$1 as deleteProperty, escapePath, flatKeys, getProperty as getObjectValueByPath, getProperty$1 as getProperty, hasProperty as hasObjectValueByPath, hasProperty$1 as hasProperty, isEmptyObject, isObject, isPlainObject, keysToCamelCase, keysToSnakeCase, mapKeys, mapValues, omit, parsePath, pick, setObjectValueByPath, setProperty, stringifyPath, unflatten };
+export { CleanOptions, KeysToCamelCase, KeysToSnakeCase, ToCamelCase, ToSnakeCase, cleanObject, deepClone, deepEqual, deepMerge, deepMergeMany, deleteProperty as deleteObjectPropertyByPath, deleteProperty$1 as deleteProperty, escapePath, flatKeys, getProperty as getObjectValueByPath, getProperty$1 as getProperty, hasProperty as hasObjectValueByPath, hasProperty$1 as hasProperty, isEmptyObject, isObject, isPlainObject, keysToCamelCase, keysToSnakeCase, mapKeys, mapValues, omit, parsePath, pick, setObjectValueByPath, setProperty, stringifyPath, unflatten };

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { CleanOptions, cleanObject } from "./clean-object.js";
 import { deepMerge, deepMergeMany } from "./deep-merge.js";
 import { deleteObjectPropertyByPath as deleteProperty } from "./delete-object-property-by-path.js";
 import { getObjectValueByPath as getProperty } from "./get-object-value-by-path.js";
@@ -7,4 +8,4 @@ import { KeysToSnakeCase, ToSnakeCase, keysToSnakeCase } from "./keys-to-snake-c
 import { deepClone, deepEqual, deleteProperty as deleteProperty$1, escapePath, flatKeys, getProperty as getProperty$1, hasProperty as hasProperty$1, mapKeys, mapValues, omit, parsePath, pick, setProperty, stringifyPath, unflatten } from "./manipulation.js";
 import { setObjectValueByPath } from "./set-object-value-by-path.js";
 import { isEmptyObject, isObject, isPlainObject } from "./type-guards.js";
-export { KeysToCamelCase, KeysToSnakeCase, ToCamelCase, ToSnakeCase, deepClone, deepEqual, deepMerge, deepMergeMany, deleteProperty as deleteObjectPropertyByPath, deleteProperty$1 as deleteProperty, escapePath, flatKeys, getProperty as getObjectValueByPath, getProperty$1 as getProperty, hasProperty as hasObjectValueByPath, hasProperty$1 as hasProperty, isEmptyObject, isObject, isPlainObject, keysToCamelCase, keysToSnakeCase, mapKeys, mapValues, omit, parsePath, pick, setObjectValueByPath, setProperty, stringifyPath, unflatten };
+export { CleanOptions, KeysToCamelCase, KeysToSnakeCase, ToCamelCase, ToSnakeCase, cleanObject, deepClone, deepEqual, deepMerge, deepMergeMany, deleteProperty as deleteObjectPropertyByPath, deleteProperty$1 as deleteProperty, escapePath, flatKeys, getProperty as getObjectValueByPath, getProperty$1 as getProperty, hasProperty as hasObjectValueByPath, hasProperty$1 as hasProperty, isEmptyObject, isObject, isPlainObject, keysToCamelCase, keysToSnakeCase, mapKeys, mapValues, omit, parsePath, pick, setObjectValueByPath, setProperty, stringifyPath, unflatten };

package/dist/index.js

@@ -1 +1,12 @@
-import{deepMerge as e,deepMergeMany as t}from"./deep-merge.js";import{deleteObjectPropertyByPath as n}from"./delete-object-property-by-path.js";import{getObjectValueByPath as r}from"./get-object-value-by-path.js";import{hasObjectValueByPath as i}from"./has-object-value-by-path.js";import{keysToCamelCase as a}from"./keys-to-camel-case.js";import{keysToSnakeCase as o}from"./keys-to-snake-case.js";import{deepClone as s,deepEqual as c,deleteProperty as l,escapePath as u,flatKeys as d,getProperty as f,hasProperty as p,mapKeys as m,mapValues as h,omit as g,parsePath as _,pick as v,setProperty as y,stringifyPath as b,unflatten as x}from"./manipulation.js";import{setObjectValueByPath as S}from"./set-object-value-by-path.js";import{isEmptyObject as C,isObject as w,isPlainObject as T}from"./type-guards.js";export{s as deepClone,c as deepEqual,e as deepMerge,t as deepMergeMany,n as deleteObjectPropertyByPath,l as deleteProperty,u as escapePath,d as flatKeys,r as getObjectValueByPath,f as getProperty,i as hasObjectValueByPath,p as hasProperty,C as isEmptyObject,w as isObject,T as isPlainObject,a as keysToCamelCase,o as keysToSnakeCase,m as mapKeys,h as mapValues,g as omit,_ as parsePath,v as pick,S as setObjectValueByPath,y as setProperty,b as stringifyPath,x as unflatten};
+import { isEmptyObject, isObject, isPlainObject } from "./type-guards.js";
+import { cleanObject } from "./clean-object.js";
+import { deepMerge, deepMergeMany } from "./deep-merge.js";
+import { deleteObjectPropertyByPath as deleteProperty } from "./delete-object-property-by-path.js";
+import { getObjectValueByPath as getProperty } from "./get-object-value-by-path.js";
+import { hasObjectValueByPath as hasProperty } from "./has-object-value-by-path.js";
+import { keysToCamelCase } from "./keys-to-camel-case.js";
+import { keysToSnakeCase } from "./keys-to-snake-case.js";
+import { deepClone, deepEqual, deleteProperty as deleteProperty$1, escapePath, flatKeys, getProperty as getProperty$1, hasProperty as hasProperty$1, mapKeys, mapValues, omit, parsePath, pick, setProperty, stringifyPath, unflatten } from "./manipulation.js";
+import { setObjectValueByPath } from "./set-object-value-by-path.js";
+
+export { cleanObject, deepClone, deepEqual, deepMerge, deepMergeMany, deleteProperty as deleteObjectPropertyByPath, deleteProperty$1 as deleteProperty, escapePath, flatKeys, getProperty as getObjectValueByPath, getProperty$1 as getProperty, hasProperty as hasObjectValueByPath, hasProperty$1 as hasProperty, isEmptyObject, isObject, isPlainObject, keysToCamelCase, keysToSnakeCase, mapKeys, mapValues, omit, parsePath, pick, setObjectValueByPath, setProperty, stringifyPath, unflatten };

package/dist/keys-to-camel-case.cjs

@@ -1 +1,18 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`);let t=require(`@pixpilot/string`);t=e.__toESM(t);function n(e){if(Array.isArray(e))return e.map(n);if(typeof e!=`object`||!e)return e;let r={};for(let[i,a]of Object.entries(e)){let e=(0,t.toCamelCase)(i);r[e]=n(a)}return r}exports.keysToCamelCase=n;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let __pixpilot_string = require("@pixpilot/string");
+__pixpilot_string = require_rolldown_runtime.__toESM(__pixpilot_string);
+
+//#region src/keys-to-camel-case.ts
+function keysToCamelCase(obj) {
+	if (Array.isArray(obj)) return obj.map(keysToCamelCase);
+	if (obj === null || typeof obj !== "object") return obj;
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const camelKey = (0, __pixpilot_string.toCamelCase)(key);
+		result[camelKey] = keysToCamelCase(value);
+	}
+	return result;
+}
+
+//#endregion
+exports.keysToCamelCase = keysToCamelCase;

package/dist/keys-to-camel-case.d.cts

@@ -1,6 +1,17 @@
 //#region src/keys-to-camel-case.d.ts
-type ToCamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}` ? `${P1}${Uppercase<P2>}${ToCamelCase<P3>}` : S;
-type KeysToCamelCase<T> = { [K in keyof T as ToCamelCase<string & K>]: T[K] extends Record<string, unknown> ? KeysToCamelCase<T[K]> : T[K] extends readonly (infer U)[] ? U extends Record<string, unknown> ? readonly KeysToCamelCase<U>[] : T[K] : T[K] };
-declare function keysToCamelCase<T>(obj: T): T extends Record<string, unknown> ? KeysToCamelCase<T> : T;
+type CamelizeSegment<S extends string> = S extends '' ? '' : Capitalize<Lowercase<S>>;
+/**
+ * Convert snake_case to camelCase at the type level.
+ *
+ * This intentionally matches the runtime behavior of `change-case`'s `camelCase`
+ * for underscores:
+ * - ignores leading/consecutive underscores
+ * - lowercases words
+ */
+type ToCamelCase<S extends string, IsFirst extends boolean = true> = S extends `${infer Head}_${infer Tail}` ? Head extends '' ? ToCamelCase<Tail, IsFirst> : `${IsFirst extends true ? Lowercase<Head> : CamelizeSegment<Head>}${ToCamelCase<Tail, false>}` : S extends '' ? '' : IsFirst extends true ? Lowercase<S> : CamelizeSegment<S>;
+type Builtin = Date | RegExp | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object>;
+type TupleToCamelCase<T extends readonly unknown[]> = { [I in keyof T]: KeysToCamelCase<T[I]> };
+type KeysToCamelCase<T> = T extends Builtin ? T : T extends ((...args: unknown[]) => unknown) ? T : T extends readonly unknown[] ? number extends T['length'] ? KeysToCamelCase<T[number]>[] : TupleToCamelCase<T> : T extends object ? { [K in keyof T as K extends string ? ToCamelCase<K> : K]: KeysToCamelCase<T[K]> } : T;
+declare function keysToCamelCase<T>(obj: T): KeysToCamelCase<T>;
 //#endregion
 export { KeysToCamelCase, ToCamelCase, keysToCamelCase };

package/dist/keys-to-camel-case.d.ts

@@ -1,6 +1,17 @@
 //#region src/keys-to-camel-case.d.ts
-type ToCamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}` ? `${P1}${Uppercase<P2>}${ToCamelCase<P3>}` : S;
-type KeysToCamelCase<T> = { [K in keyof T as ToCamelCase<string & K>]: T[K] extends Record<string, unknown> ? KeysToCamelCase<T[K]> : T[K] extends readonly (infer U)[] ? U extends Record<string, unknown> ? readonly KeysToCamelCase<U>[] : T[K] : T[K] };
-declare function keysToCamelCase<T>(obj: T): T extends Record<string, unknown> ? KeysToCamelCase<T> : T;
+type CamelizeSegment<S extends string> = S extends '' ? '' : Capitalize<Lowercase<S>>;
+/**
+ * Convert snake_case to camelCase at the type level.
+ *
+ * This intentionally matches the runtime behavior of `change-case`'s `camelCase`
+ * for underscores:
+ * - ignores leading/consecutive underscores
+ * - lowercases words
+ */
+type ToCamelCase<S extends string, IsFirst extends boolean = true> = S extends `${infer Head}_${infer Tail}` ? Head extends '' ? ToCamelCase<Tail, IsFirst> : `${IsFirst extends true ? Lowercase<Head> : CamelizeSegment<Head>}${ToCamelCase<Tail, false>}` : S extends '' ? '' : IsFirst extends true ? Lowercase<S> : CamelizeSegment<S>;
+type Builtin = Date | RegExp | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object>;
+type TupleToCamelCase<T extends readonly unknown[]> = { [I in keyof T]: KeysToCamelCase<T[I]> };
+type KeysToCamelCase<T> = T extends Builtin ? T : T extends ((...args: unknown[]) => unknown) ? T : T extends readonly unknown[] ? number extends T['length'] ? KeysToCamelCase<T[number]>[] : TupleToCamelCase<T> : T extends object ? { [K in keyof T as K extends string ? ToCamelCase<K> : K]: KeysToCamelCase<T[K]> } : T;
+declare function keysToCamelCase<T>(obj: T): KeysToCamelCase<T>;
 //#endregion
 export { KeysToCamelCase, ToCamelCase, keysToCamelCase };

package/dist/keys-to-camel-case.js

@@ -1 +1,16 @@
-import{toCamelCase as e}from"@pixpilot/string";function t(n){if(Array.isArray(n))return n.map(t);if(typeof n!=`object`||!n)return n;let r={};for(let[i,a]of Object.entries(n)){let n=e(i);r[n]=t(a)}return r}export{t as keysToCamelCase};
+import { toCamelCase } from "@pixpilot/string";
+
+//#region src/keys-to-camel-case.ts
+function keysToCamelCase(obj) {
+	if (Array.isArray(obj)) return obj.map(keysToCamelCase);
+	if (obj === null || typeof obj !== "object") return obj;
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const camelKey = toCamelCase(key);
+		result[camelKey] = keysToCamelCase(value);
+	}
+	return result;
+}
+
+//#endregion
+export { keysToCamelCase };

package/dist/keys-to-snake-case.cjs

@@ -1 +1,21 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`);let t=require(`@pixpilot/string`);t=e.__toESM(t);function n(e){if(Array.isArray(e))return e.map(n);if(typeof e!=`object`||!e)return e;let r={};for(let[i,a]of Object.entries(e)){let e=(0,t.toSnakeCase)(i);r[e]=n(a)}return r}exports.keysToSnakeCase=n;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let __pixpilot_string = require("@pixpilot/string");
+__pixpilot_string = require_rolldown_runtime.__toESM(__pixpilot_string);
+
+//#region src/keys-to-snake-case.ts
+/**
+* Converts object keys from camelCase to snake_case recursively
+*/
+function keysToSnakeCase(obj) {
+	if (Array.isArray(obj)) return obj.map(keysToSnakeCase);
+	if (obj === null || typeof obj !== "object") return obj;
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const snakeKey = (0, __pixpilot_string.toSnakeCase)(key);
+		result[snakeKey] = keysToSnakeCase(value);
+	}
+	return result;
+}
+
+//#endregion
+exports.keysToSnakeCase = keysToSnakeCase;

package/dist/keys-to-snake-case.d.cts

@@ -1,9 +1,17 @@
 //#region src/keys-to-snake-case.d.ts
-type ToSnakeCase<S extends string> = S extends `${infer T}${infer U}` ? `${T extends Uppercase<T> ? '_' : ''}${Lowercase<T>}${ToSnakeCase<U>}` : S;
-type KeysToSnakeCase<T$1> = { [K in keyof T$1 as ToSnakeCase<string & K>]: T$1[K] extends Record<string, unknown> ? KeysToSnakeCase<T$1[K]> : T$1[K] extends readonly (infer U)[] ? U extends Record<string, unknown> ? readonly KeysToSnakeCase<U>[] : T$1[K] : T$1[K] };
+/**
+ * Convert camelCase to snake_case at the type level.
+ *
+ * This intentionally matches the runtime behavior of `change-case`'s `snakeCase`
+ * for camelCase conversion: inserts underscores before uppercase letters and lowercases.
+ */
+type ToSnakeCase<S extends string> = S extends `${infer P1}${infer P2}${infer P3}` ? P1 extends Lowercase<P1> ? P2 extends Uppercase<P2> ? `${P1}_${ToSnakeCase<`${Lowercase<P2>}${P3}`>}` : `${P1}${ToSnakeCase<`${P2}${P3}`>}` : S : S;
+type Builtin = Date | RegExp | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object>;
+type TupleToSnakeCase<T extends readonly unknown[]> = { [I in keyof T]: KeysToSnakeCase<T[I]> };
+type KeysToSnakeCase<T> = T extends Builtin ? T : T extends ((...args: unknown[]) => unknown) ? T : T extends readonly unknown[] ? number extends T['length'] ? KeysToSnakeCase<T[number]>[] : TupleToSnakeCase<T> : T extends object ? { [K in keyof T as K extends string ? ToSnakeCase<K> : K]: KeysToSnakeCase<T[K]> } : T;
 /**
  * Converts object keys from camelCase to snake_case recursively
  */
-declare function keysToSnakeCase<T$1>(obj: T$1): T$1 extends Record<string, unknown> ? KeysToSnakeCase<T$1> : T$1;
+declare function keysToSnakeCase<T>(obj: T): KeysToSnakeCase<T>;
 //#endregion
 export { KeysToSnakeCase, ToSnakeCase, keysToSnakeCase };

package/dist/keys-to-snake-case.d.ts

@@ -1,9 +1,17 @@
 //#region src/keys-to-snake-case.d.ts
-type ToSnakeCase<S extends string> = S extends `${infer T}${infer U}` ? `${T extends Uppercase<T> ? '_' : ''}${Lowercase<T>}${ToSnakeCase<U>}` : S;
-type KeysToSnakeCase<T$1> = { [K in keyof T$1 as ToSnakeCase<string & K>]: T$1[K] extends Record<string, unknown> ? KeysToSnakeCase<T$1[K]> : T$1[K] extends readonly (infer U)[] ? U extends Record<string, unknown> ? readonly KeysToSnakeCase<U>[] : T$1[K] : T$1[K] };
+/**
+ * Convert camelCase to snake_case at the type level.
+ *
+ * This intentionally matches the runtime behavior of `change-case`'s `snakeCase`
+ * for camelCase conversion: inserts underscores before uppercase letters and lowercases.
+ */
+type ToSnakeCase<S extends string> = S extends `${infer P1}${infer P2}${infer P3}` ? P1 extends Lowercase<P1> ? P2 extends Uppercase<P2> ? `${P1}_${ToSnakeCase<`${Lowercase<P2>}${P3}`>}` : `${P1}${ToSnakeCase<`${P2}${P3}`>}` : S : S;
+type Builtin = Date | RegExp | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object>;
+type TupleToSnakeCase<T extends readonly unknown[]> = { [I in keyof T]: KeysToSnakeCase<T[I]> };
+type KeysToSnakeCase<T> = T extends Builtin ? T : T extends ((...args: unknown[]) => unknown) ? T : T extends readonly unknown[] ? number extends T['length'] ? KeysToSnakeCase<T[number]>[] : TupleToSnakeCase<T> : T extends object ? { [K in keyof T as K extends string ? ToSnakeCase<K> : K]: KeysToSnakeCase<T[K]> } : T;
 /**
  * Converts object keys from camelCase to snake_case recursively
  */
-declare function keysToSnakeCase<T$1>(obj: T$1): T$1 extends Record<string, unknown> ? KeysToSnakeCase<T$1> : T$1;
+declare function keysToSnakeCase<T>(obj: T): KeysToSnakeCase<T>;
 //#endregion
 export { KeysToSnakeCase, ToSnakeCase, keysToSnakeCase };

package/dist/keys-to-snake-case.js

@@ -1 +1,19 @@
-import{toSnakeCase as e}from"@pixpilot/string";function t(n){if(Array.isArray(n))return n.map(t);if(typeof n!=`object`||!n)return n;let r={};for(let[i,a]of Object.entries(n)){let n=e(i);r[n]=t(a)}return r}export{t as keysToSnakeCase};
+import { toSnakeCase } from "@pixpilot/string";
+
+//#region src/keys-to-snake-case.ts
+/**
+* Converts object keys from camelCase to snake_case recursively
+*/
+function keysToSnakeCase(obj) {
+	if (Array.isArray(obj)) return obj.map(keysToSnakeCase);
+	if (obj === null || typeof obj !== "object") return obj;
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const snakeKey = toSnakeCase(key);
+		result[snakeKey] = keysToSnakeCase(value);
+	}
+	return result;
+}
+
+//#endregion
+export { keysToSnakeCase };

package/dist/manipulation.cjs

@@ -1 +1,151 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`);let t=require(`dot-prop`);t=e.__toESM(t);function n(e,t){let n={};for(let r of t)r in e&&(n[r]=e[r]);return n}function r(e,t){let n={...e};for(let e of t)delete n[e];return n}function i(e){if(typeof e!=`object`||!e)return e;if(e instanceof Date)return new Date(e.getTime());if(e instanceof RegExp)return new RegExp(e.source,e.flags);if(Array.isArray(e))return e.map(e=>i(e));let t={};for(let[n,r]of Object.entries(e))t[n]=i(r);return t}function a(e,t){if(e===t)return!0;if(typeof e!=typeof t||e===null||t===null)return!1;if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(Array.isArray(e)&&Array.isArray(t))return e.length===t.length?e.every((e,n)=>a(e,t[n])):!1;if(typeof e==`object`&&typeof t==`object`){let n=Object.keys(e),r=Object.keys(t);return n.length===r.length?n.every(n=>a(e[n],t[n])):!1}return!1}function o(e,t){let n={};for(let[r,i]of Object.entries(e))n[r]=t(i,r);return n}function s(e,t){let n={};for(let[r,i]of Object.entries(e)){let e=t(r);n[e]=i}return n}const c=t.deepKeys;exports.deepClone=i,exports.deepEqual=a,exports.deleteProperty=t.deleteProperty,exports.escapePath=t.escapePath,exports.flatKeys=c,exports.getProperty=t.getProperty,exports.hasProperty=t.hasProperty,exports.mapKeys=s,exports.mapValues=o,exports.omit=r,exports.parsePath=t.parsePath,exports.pick=n,exports.setProperty=t.setProperty,exports.stringifyPath=t.stringifyPath,exports.unflatten=t.unflatten;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let dot_prop = require("dot-prop");
+dot_prop = require_rolldown_runtime.__toESM(dot_prop);
+
+//#region src/manipulation.ts
+/**
+* Pick specific keys from an object.
+*
+* @param obj - The source object
+* @param keys - The keys to pick
+* @returns A new object with only the specified keys
+*
+* @example
+* ```typescript
+* const obj = { a: 1, b: 2, c: 3 };
+* pick(obj, ['a', 'c']); // { a: 1, c: 3 }
+* ```
+*/
+function pick(obj, keys) {
+	const result = {};
+	for (const key of keys) if (key in obj) result[key] = obj[key];
+	return result;
+}
+/**
+* Omit specific keys from an object.
+*
+* @param obj - The source object
+* @param keys - The keys to omit
+* @returns A new object without the specified keys
+*
+* @example
+* ```typescript
+* const obj = { a: 1, b: 2, c: 3 };
+* omit(obj, ['b']); // { a: 1, c: 3 }
+* ```
+*/
+function omit(obj, keys) {
+	const result = { ...obj };
+	for (const key of keys) delete result[key];
+	return result;
+}
+/**
+* Deep clone an object.
+*
+* @param obj - The object to clone
+* @returns A deep clone of the object
+*
+* @example
+* ```typescript
+* const obj = { a: 1, b: { c: 2 } };
+* const cloned = deepClone(obj);
+* cloned.b.c = 3;
+* console.log(obj.b.c); // 2 (original unchanged)
+* ```
+*/
+function deepClone(obj) {
+	if (obj === null || typeof obj !== "object") return obj;
+	if (obj instanceof Date) return new Date(obj.getTime());
+	if (obj instanceof RegExp) return new RegExp(obj.source, obj.flags);
+	if (Array.isArray(obj)) return obj.map((item) => deepClone(item));
+	const cloned = {};
+	for (const [key, value] of Object.entries(obj)) cloned[key] = deepClone(value);
+	return cloned;
+}
+/**
+* Compare two objects for deep equality.
+*
+* @param obj1 - The first object
+* @param obj2 - The second object
+* @returns True if the objects are deeply equal, false otherwise
+*
+* @example
+* ```typescript
+* deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } }); // true
+* deepEqual({ a: 1 }, { a: 2 }); // false
+* ```
+*/
+function deepEqual(obj1, obj2) {
+	if (obj1 === obj2) return true;
+	if (typeof obj1 !== typeof obj2) return false;
+	if (obj1 === null || obj2 === null) return false;
+	if (obj1 instanceof Date && obj2 instanceof Date) return obj1.getTime() === obj2.getTime();
+	if (Array.isArray(obj1) && Array.isArray(obj2)) {
+		if (obj1.length !== obj2.length) return false;
+		return obj1.every((item, index) => deepEqual(item, obj2[index]));
+	}
+	if (typeof obj1 === "object" && typeof obj2 === "object") {
+		const keys1 = Object.keys(obj1);
+		const keys2 = Object.keys(obj2);
+		if (keys1.length !== keys2.length) return false;
+		return keys1.every((key) => deepEqual(obj1[key], obj2[key]));
+	}
+	return false;
+}
+/**
+* Map over the values of an object.
+*
+* @param obj - The source object
+* @param fn - The mapping function
+* @returns A new object with mapped values
+*
+* @example
+* ```typescript
+* const obj = { a: 1, b: 2, c: 3 };
+* mapValues(obj, (value) => value * 2); // { a: 2, b: 4, c: 6 }
+* ```
+*/
+function mapValues(obj, fn) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) result[key] = fn(value, key);
+	return result;
+}
+/**
+* Map over the keys of an object.
+*
+* @param obj - The source object
+* @param fn - The mapping function
+* @returns A new object with mapped keys
+*
+* @example
+* ```typescript
+* const obj = { a: 1, b: 2 };
+* mapKeys(obj, (key) => key.toUpperCase()); // { A: 1, B: 2 }
+* ```
+*/
+function mapKeys(obj, fn) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const newKey = fn(key);
+		result[newKey] = value;
+	}
+	return result;
+}
+const flatKeys = dot_prop.deepKeys;
+
+//#endregion
+exports.deepClone = deepClone;
+exports.deepEqual = deepEqual;
+exports.deleteProperty = dot_prop.deleteProperty;
+exports.escapePath = dot_prop.escapePath;
+exports.flatKeys = flatKeys;
+exports.getProperty = dot_prop.getProperty;
+exports.hasProperty = dot_prop.hasProperty;
+exports.mapKeys = mapKeys;
+exports.mapValues = mapValues;
+exports.omit = omit;
+exports.parsePath = dot_prop.parsePath;
+exports.pick = pick;
+exports.setProperty = dot_prop.setProperty;
+exports.stringifyPath = dot_prop.stringifyPath;
+exports.unflatten = dot_prop.unflatten;

package/dist/manipulation.js

@@ -1 +1,135 @@
-import{deepKeys as e,deleteProperty as t,escapePath as n,getProperty as r,hasProperty as i,parsePath as a,setProperty as o,stringifyPath as s,unflatten as c}from"dot-prop";function l(e,t){let n={};for(let r of t)r in e&&(n[r]=e[r]);return n}function u(e,t){let n={...e};for(let e of t)delete n[e];return n}function d(e){if(typeof e!=`object`||!e)return e;if(e instanceof Date)return new Date(e.getTime());if(e instanceof RegExp)return new RegExp(e.source,e.flags);if(Array.isArray(e))return e.map(e=>d(e));let t={};for(let[n,r]of Object.entries(e))t[n]=d(r);return t}function f(e,t){if(e===t)return!0;if(typeof e!=typeof t||e===null||t===null)return!1;if(e instanceof Date&&t instanceof Date)return e.getTime()===t.getTime();if(Array.isArray(e)&&Array.isArray(t))return e.length===t.length?e.every((e,n)=>f(e,t[n])):!1;if(typeof e==`object`&&typeof t==`object`){let n=Object.keys(e),r=Object.keys(t);return n.length===r.length?n.every(n=>f(e[n],t[n])):!1}return!1}function p(e,t){let n={};for(let[r,i]of Object.entries(e))n[r]=t(i,r);return n}function m(e,t){let n={};for(let[r,i]of Object.entries(e)){let e=t(r);n[e]=i}return n}const h=e;export{d as deepClone,f as deepEqual,t as deleteProperty,n as escapePath,h as flatKeys,r as getProperty,i as hasProperty,m as mapKeys,p as mapValues,u as omit,a as parsePath,l as pick,o as setProperty,s as stringifyPath,c as unflatten};
+import { deepKeys, deleteProperty, escapePath, getProperty, hasProperty, parsePath, setProperty, stringifyPath, unflatten } from "dot-prop";
+
+//#region src/manipulation.ts
+/**
+* Pick specific keys from an object.
+*
+* @param obj - The source object
+* @param keys - The keys to pick
+* @returns A new object with only the specified keys
+*
+* @example
+* ```typescript
+* const obj = { a: 1, b: 2, c: 3 };
+* pick(obj, ['a', 'c']); // { a: 1, c: 3 }
+* ```
+*/
+function pick(obj, keys) {
+	const result = {};
+	for (const key of keys) if (key in obj) result[key] = obj[key];
+	return result;
+}
+/**
+* Omit specific keys from an object.
+*
+* @param obj - The source object
+* @param keys - The keys to omit
+* @returns A new object without the specified keys
+*
+* @example
+* ```typescript
+* const obj = { a: 1, b: 2, c: 3 };
+* omit(obj, ['b']); // { a: 1, c: 3 }
+* ```
+*/
+function omit(obj, keys) {
+	const result = { ...obj };
+	for (const key of keys) delete result[key];
+	return result;
+}
+/**
+* Deep clone an object.
+*
+* @param obj - The object to clone
+* @returns A deep clone of the object
+*
+* @example
+* ```typescript
+* const obj = { a: 1, b: { c: 2 } };
+* const cloned = deepClone(obj);
+* cloned.b.c = 3;
+* console.log(obj.b.c); // 2 (original unchanged)
+* ```
+*/
+function deepClone(obj) {
+	if (obj === null || typeof obj !== "object") return obj;
+	if (obj instanceof Date) return new Date(obj.getTime());
+	if (obj instanceof RegExp) return new RegExp(obj.source, obj.flags);
+	if (Array.isArray(obj)) return obj.map((item) => deepClone(item));
+	const cloned = {};
+	for (const [key, value] of Object.entries(obj)) cloned[key] = deepClone(value);
+	return cloned;
+}
+/**
+* Compare two objects for deep equality.
+*
+* @param obj1 - The first object
+* @param obj2 - The second object
+* @returns True if the objects are deeply equal, false otherwise
+*
+* @example
+* ```typescript
+* deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } }); // true
+* deepEqual({ a: 1 }, { a: 2 }); // false
+* ```
+*/
+function deepEqual(obj1, obj2) {
+	if (obj1 === obj2) return true;
+	if (typeof obj1 !== typeof obj2) return false;
+	if (obj1 === null || obj2 === null) return false;
+	if (obj1 instanceof Date && obj2 instanceof Date) return obj1.getTime() === obj2.getTime();
+	if (Array.isArray(obj1) && Array.isArray(obj2)) {
+		if (obj1.length !== obj2.length) return false;
+		return obj1.every((item, index) => deepEqual(item, obj2[index]));
+	}
+	if (typeof obj1 === "object" && typeof obj2 === "object") {
+		const keys1 = Object.keys(obj1);
+		const keys2 = Object.keys(obj2);
+		if (keys1.length !== keys2.length) return false;
+		return keys1.every((key) => deepEqual(obj1[key], obj2[key]));
+	}
+	return false;
+}
+/**
+* Map over the values of an object.
+*
+* @param obj - The source object
+* @param fn - The mapping function
+* @returns A new object with mapped values
+*
+* @example
+* ```typescript
+* const obj = { a: 1, b: 2, c: 3 };
+* mapValues(obj, (value) => value * 2); // { a: 2, b: 4, c: 6 }
+* ```
+*/
+function mapValues(obj, fn) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) result[key] = fn(value, key);
+	return result;
+}
+/**
+* Map over the keys of an object.
+*
+* @param obj - The source object
+* @param fn - The mapping function
+* @returns A new object with mapped keys
+*
+* @example
+* ```typescript
+* const obj = { a: 1, b: 2 };
+* mapKeys(obj, (key) => key.toUpperCase()); // { A: 1, B: 2 }
+* ```
+*/
+function mapKeys(obj, fn) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const newKey = fn(key);
+		result[newKey] = value;
+	}
+	return result;
+}
+const flatKeys = deepKeys;
+
+//#endregion
+export { deepClone, deepEqual, deleteProperty, escapePath, flatKeys, getProperty, hasProperty, mapKeys, mapValues, omit, parsePath, pick, setProperty, stringifyPath, unflatten };

package/dist/set-object-value-by-path.cjs

@@ -1 +1,27 @@
-const e=require(`./_virtual/rolldown_runtime.cjs`);let t=require(`dot-prop`);t=e.__toESM(t);function n(e,n,r,i={}){i.deleteUndefine&&r===void 0?(0,t.deleteProperty)(e,n):(0,t.setProperty)(e,n,r)}exports.setObjectValueByPath=n;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let dot_prop = require("dot-prop");
+dot_prop = require_rolldown_runtime.__toESM(dot_prop);
+
+//#region src/set-object-value-by-path.ts
+/**
+* Set a nested value in an object using a path string.
+*
+* @param object - The target object
+* @param path - The path to set the value at (e.g., 'a.b.c')
+* @param value - The value to set
+* @param options - Options for setting the value
+* @param options.deleteUndefine - If true, delete the property when value is undefined
+*
+* @example
+* ```typescript
+* const obj = { a: { b: {} } };
+* setObjectValueByPath(obj, 'a.b.c', 42); // { a: { b: { c: 42 } } }
+* ```
+*/
+function setObjectValueByPath(object, path, value, options = {}) {
+	if (options.deleteUndefine && value === void 0) (0, dot_prop.deleteProperty)(object, path);
+	else (0, dot_prop.setProperty)(object, path, value);
+}
+
+//#endregion
+exports.setObjectValueByPath = setObjectValueByPath;

package/dist/set-object-value-by-path.js

@@ -1 +1,25 @@
-import{deleteProperty as e,setProperty as t}from"dot-prop";function n(n,r,i,a={}){a.deleteUndefine&&i===void 0?e(n,r):t(n,r,i)}export{n as setObjectValueByPath};
+import { deleteProperty, setProperty } from "dot-prop";
+
+//#region src/set-object-value-by-path.ts
+/**
+* Set a nested value in an object using a path string.
+*
+* @param object - The target object
+* @param path - The path to set the value at (e.g., 'a.b.c')
+* @param value - The value to set
+* @param options - Options for setting the value
+* @param options.deleteUndefine - If true, delete the property when value is undefined
+*
+* @example
+* ```typescript
+* const obj = { a: { b: {} } };
+* setObjectValueByPath(obj, 'a.b.c', 42); // { a: { b: { c: 42 } } }
+* ```
+*/
+function setObjectValueByPath(object, path, value, options = {}) {
+	if (options.deleteUndefine && value === void 0) deleteProperty(object, path);
+	else setProperty(object, path, value);
+}
+
+//#endregion
+export { setObjectValueByPath };

package/dist/type-guards.cjs

@@ -1 +1,61 @@
-function e(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function t(t){if(!e(t))return!1;let n=Object.getPrototypeOf(t);return n===null||n===Object.prototype}function n(t){return e(t)&&Object.keys(t).length===0}exports.isEmptyObject=n,exports.isObject=e,exports.isPlainObject=t;
+
+//#region src/type-guards.ts
+/**
+* Type guard to check if a value is an object (and not null or an array).
+*
+* @param value - The value to check
+* @returns True if the value is an object, false otherwise
+*
+* @example
+* ```typescript
+* isObject({}); // true
+* isObject({ key: 'value' }); // true
+* isObject([]); // false
+* isObject(null); // false
+* isObject('string'); // false
+* ```
+*/
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Type guard to check if a value is a plain object
+* (created with {} or new Object(), not a class instance).
+*
+* @param value - The value to check
+* @returns True if the value is a plain object, false otherwise
+*
+* @example
+* ```typescript
+* isPlainObject({}); // true
+* isPlainObject({ key: 'value' }); // true
+* isPlainObject(new Date()); // false
+* isPlainObject([]); // false
+* ```
+*/
+function isPlainObject(value) {
+	if (!isObject(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === null || proto === Object.prototype;
+}
+/**
+* Type guard to check if a value is an empty object.
+*
+* @param value - The value to check
+* @returns True if the value is an empty object, false otherwise
+*
+* @example
+* ```typescript
+* isEmptyObject({}); // true
+* isEmptyObject({ key: 'value' }); // false
+* isEmptyObject([]); // false
+* ```
+*/
+function isEmptyObject(value) {
+	return isObject(value) && Object.keys(value).length === 0;
+}
+
+//#endregion
+exports.isEmptyObject = isEmptyObject;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;

package/dist/type-guards.js

@@ -1 +1,58 @@
-function e(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function t(t){if(!e(t))return!1;let n=Object.getPrototypeOf(t);return n===null||n===Object.prototype}function n(t){return e(t)&&Object.keys(t).length===0}export{n as isEmptyObject,e as isObject,t as isPlainObject};
+//#region src/type-guards.ts
+/**
+* Type guard to check if a value is an object (and not null or an array).
+*
+* @param value - The value to check
+* @returns True if the value is an object, false otherwise
+*
+* @example
+* ```typescript
+* isObject({}); // true
+* isObject({ key: 'value' }); // true
+* isObject([]); // false
+* isObject(null); // false
+* isObject('string'); // false
+* ```
+*/
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Type guard to check if a value is a plain object
+* (created with {} or new Object(), not a class instance).
+*
+* @param value - The value to check
+* @returns True if the value is a plain object, false otherwise
+*
+* @example
+* ```typescript
+* isPlainObject({}); // true
+* isPlainObject({ key: 'value' }); // true
+* isPlainObject(new Date()); // false
+* isPlainObject([]); // false
+* ```
+*/
+function isPlainObject(value) {
+	if (!isObject(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === null || proto === Object.prototype;
+}
+/**
+* Type guard to check if a value is an empty object.
+*
+* @param value - The value to check
+* @returns True if the value is an empty object, false otherwise
+*
+* @example
+* ```typescript
+* isEmptyObject({}); // true
+* isEmptyObject({ key: 'value' }); // false
+* isEmptyObject([]); // false
+* ```
+*/
+function isEmptyObject(value) {
+	return isObject(value) && Object.keys(value).length === 0;
+}
+
+//#endregion
+export { isEmptyObject, isObject, isPlainObject };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pixpilot/object",
   "type": "module",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "description": "A collection of utility functions for object manipulation and transformation.",
   "author": "Pixpilot <m.doaie@hotmail.com>",
   "license": "MIT",
@@ -27,7 +27,7 @@
   "dependencies": {
     "@fastify/deepmerge": "^3.1.0",
     "dot-prop": "^10.1.0",
-    "@pixpilot/string": "2.3.0"
+    "@pixpilot/string": "2.4.0"
   },
   "devDependencies": {
     "@manypkg/get-packages": "^3.1.0",