@helpers4/object 3.0.1 → 3.0.3

package/README.md

@@ -12,6 +12,7 @@ A set of helpers for working with URLs.
 [https://helpers4.dev/typescript/categories/object/](https://helpers4.dev/typescript/categories/object/)
 
 <!-- AUTOMATIC-METHODS -->
+- camelCaseKeys
 - clone
 - cloneDeep
 - compact
@@ -24,16 +25,22 @@ A set of helpers for working with URLs.
 - invert
 - isEmpty
 - isNonEmpty
+- kebabCaseKeys
 - map
+- mapDeep
 - mergeDeep
 - omit
 - omitBy
 - parsePropertyPath
+- pascalCaseKeys
 - pick
 - pickBy
 - removeUndefinedNull
 - safeJsonParse
 - set
+- snakeCaseKeys
+- sortKeys
+- titleCaseKeys
 - unflatten
 - unset
 - update
@@ -50,11 +57,13 @@ A set of helpers for working with URLs.
 - [function](../function)
 - [guard](../guard)
 - [id](../id)
+- [map](../map)
 - [markdown](../markdown)
 - [node](../node)
 - [number](../number)
 - [observable](../observable)
 - [promise](../promise)
+- [set](../set)
 - [string](../string)
 - [type](../type)
 - [url](../url)
@@ -74,12 +83,14 @@ A set of helpers for working with URLs.
 | function | [@helpers4/function](https://www.npmjs.com/package/@helpers4/function) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/function) | Function utilities and type guards |
 | guard | [@helpers4/guard](https://www.npmjs.com/package/@helpers4/guard) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/guard) | Runtime type guard utilities |
 | id | [@helpers4/id](https://www.npmjs.com/package/@helpers4/id) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/id) | Unique identifier generation utilities |
+| map | [@helpers4/map](https://www.npmjs.com/package/@helpers4/map) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/map) | Native Map manipulation utilities |
 | markdown | [@helpers4/markdown](https://www.npmjs.com/package/@helpers4/markdown) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/markdown) | Markdown formatting and escaping utilities |
 | node | [@helpers4/node](https://www.npmjs.com/package/@helpers4/node) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/node) | Node.js-specific utilities |
 | number | [@helpers4/number](https://www.npmjs.com/package/@helpers4/number) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/number) | Number utility functions and validation |
 | object | [@helpers4/object](https://www.npmjs.com/package/@helpers4/object) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/object) | Object manipulation utilities |
 | observable | [@helpers4/observable](https://www.npmjs.com/package/@helpers4/observable) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/observable) | Observable utilities and combinators |
 | promise | [@helpers4/promise](https://www.npmjs.com/package/@helpers4/promise) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/promise) | Promise utilities and error handling |
+| set | [@helpers4/set](https://www.npmjs.com/package/@helpers4/set) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/set) | Native Set manipulation utilities |
 | string | [@helpers4/string](https://www.npmjs.com/package/@helpers4/string) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/string) | String manipulation and formatting utilities |
 | type | [@helpers4/type](https://www.npmjs.com/package/@helpers4/type) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/type) | Compile-time TypeScript utility types |
 | url | [@helpers4/url](https://www.npmjs.com/package/@helpers4/url) | [Source](https://github.com/helpers4/helpers4/tree/main/helpers/url) | URL parsing and manipulation utilities |

package/lib/index.d.ts

@@ -1,3 +1,24 @@
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Recursively transforms every key of a plain object (including keys nested inside arrays and
+ * nested objects) to camelCase. Handles snake_case, kebab-case, PascalCase, and space-separated
+ * keys. Non-plain-object values (arrays' items aside) — `Date`, `Map`, `Set`, class instances,
+ * primitives — are left untouched, only their position is walked into. An entry whose
+ * transformed key is a prototype-polluting string (`__proto__`, `constructor`, `prototype`) is
+ * silently skipped, same as the rest of `@helpers4/object`.
+ * @param value - The object (or array of objects) to transform
+ * @returns A new value with every plain-object key converted to camelCase
+ * @example
+ * camelCaseKeys({ user_name: 'Alice', home_address: { zip_code: '12345' } })
+ * // => { userName: 'Alice', homeAddress: { zipCode: '12345' } }
+ * @since 3.0.3
+ */
+declare function camelCaseKeys<T>(value: T): T;
+
 /**
  * This file is part of helpers4.
  * Copyright (C) 2025 baxyz
@@ -530,6 +551,27 @@ declare function isEmpty(value: Record<PropertyKey, unknown> | null | undefined)
  */
 declare function isNonEmpty(value: Record<PropertyKey, unknown> | null | undefined): value is Record<PropertyKey, unknown>;
 
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Recursively transforms every key of a plain object (including keys nested inside arrays and
+ * nested objects) to kebab-case. Handles snake_case, camelCase, PascalCase, and space-separated
+ * keys. Non-plain-object values — `Date`, `Map`, `Set`, class instances, primitives — are left
+ * untouched, only their position is walked into. An entry whose transformed key is a
+ * prototype-polluting string (`__proto__`, `constructor`, `prototype`) is silently skipped,
+ * same as the rest of `@helpers4/object`.
+ * @param value - The object (or array of objects) to transform
+ * @returns A new value with every plain-object key converted to kebab-case
+ * @example
+ * kebabCaseKeys({ userName: 'Alice', homeAddress: { zipCode: '12345' } })
+ * // => { 'user-name': 'Alice', 'home-address': { 'zip-code': '12345' } }
+ * @since 3.0.3
+ */
+declare function kebabCaseKeys<T>(value: T): T;
+
 /**
  * This file is part of helpers4.
  * Copyright (C) 2025 baxyz
@@ -565,6 +607,46 @@ declare function isNonEmpty(value: Record<PropertyKey, unknown> | null | undefin
  */
 declare function map<TObj extends Record<string, unknown>, TVal = TObj[keyof TObj], TKey extends PropertyKey = keyof TObj>(obj: TObj | null | undefined, mapValue?: (value: TObj[keyof TObj], key: keyof TObj) => TVal, mapKey?: (key: keyof TObj, value: TObj[keyof TObj]) => TKey): Record<TKey, TVal>;
 
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Recursively transforms the keys and/or values of a plain object — the deep counterpart to
+ * {@link map}, which only transforms the top level. Descends into nested plain objects and
+ * arrays of them; `Date`, `Map`, `Set`, class instances, and primitives are left untouched
+ * (only their position is walked into, matching {@link cloneDeep}'s notion of what counts
+ * as a plain-data node worth recursing into).
+ *
+ * Both callbacks are optional and default to identity (no transformation). `mapKey` is called
+ * with the *original* key and value (before any recursive value transform); `mapValue` receives
+ * the already-recursed value. Entries whose mapped key is a prototype-polluting string
+ * (`__proto__`, `constructor`, `prototype`) are silently skipped, same as {@link map}.
+ *
+ * Array elements also go through `mapValue` (with their stringified index as `key`, since
+ * arrays have no property keys of their own) — so values inside a plain array, not just object
+ * properties, get transformed too. `mapKey` is never called for array elements, since there is
+ * no key to rename.
+ *
+ * @param obj - The value to transform (typically an object, or an array of objects)
+ * @param mapValue - Callback called with `(value, key)` for each entry's (already-recursed) value.
+ *   For array elements, `key` is the element's index as a string. Defaults to identity.
+ * @param mapKey - Callback called with `(key, value)` for each object entry. Defaults to identity.
+ * @returns A new value with every plain-object key/value transformed
+ * @example
+ * mapDeep({ a: { b: 1 } }, v => (typeof v === 'number' ? v * 10 : v))
+ * // => { a: { b: 10 } }
+ * @example
+ * mapDeep({ user_name: 'Alice' }, undefined, key => key.toUpperCase())
+ * // => { USER_NAME: 'Alice' }
+ * @example
+ * mapDeep({ tags: [1, 2, 3] }, v => (typeof v === 'number' ? v * 10 : v))
+ * // => { tags: [10, 20, 30] }
+ * @since 3.0.3
+ */
+declare function mapDeep<T>(obj: T, mapValue?: (value: unknown, key: string) => unknown, mapKey?: (key: string, value: unknown) => PropertyKey): T;
+
 /**
  * This file is part of helpers4.
  * Copyright (C) 2025 baxyz
@@ -700,6 +782,27 @@ declare function omitBy<T extends Record<string, unknown>>(obj: T | undefined |
  */
 declare function parsePropertyPath(path: string): readonly (string | number)[];
 
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Recursively transforms every key of a plain object (including keys nested inside arrays and
+ * nested objects) to PascalCase. Handles camelCase, snake_case, kebab-case, and space-separated
+ * keys. Non-plain-object values — `Date`, `Map`, `Set`, class instances, primitives — are left
+ * untouched, only their position is walked into. An entry whose transformed key is a
+ * prototype-polluting string (`__proto__`, `constructor`, `prototype`) is silently skipped,
+ * same as the rest of `@helpers4/object`.
+ * @param value - The object (or array of objects) to transform
+ * @returns A new value with every plain-object key converted to PascalCase
+ * @example
+ * pascalCaseKeys({ user_name: 'Alice', home_address: { zip_code: '12345' } })
+ * // => { UserName: 'Alice', HomeAddress: { ZipCode: '12345' } }
+ * @since 3.0.3
+ */
+declare function pascalCaseKeys<T>(value: T): T;
+
 /**
  * This file is part of helpers4.
  * Copyright (C) 2025 baxyz
@@ -844,6 +947,76 @@ declare function safeJsonParse<T>(input: string, fallback: T): T;
  */
 declare function set<T extends object, const P extends string | readonly PropertyKey[], V extends DeepGet<T, ParsePath<P>>>(obj: T, path: P, value: V): string extends P ? T : readonly PropertyKey[] extends P ? T : ContainsUnsafeStringKey<ParsePath<P>> extends true ? T : DeepSet<T, ParsePath<P>, V>;
 
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Recursively transforms every key of a plain object (including keys nested inside arrays and
+ * nested objects) to snake_case. Handles camelCase, PascalCase, kebab-case, and space-separated
+ * keys. Non-plain-object values — `Date`, `Map`, `Set`, class instances, primitives — are left
+ * untouched, only their position is walked into. An entry whose transformed key is a
+ * prototype-polluting string (`__proto__`, `constructor`, `prototype`) is silently skipped,
+ * same as the rest of `@helpers4/object`.
+ * @param value - The object (or array of objects) to transform
+ * @returns A new value with every plain-object key converted to snake_case
+ * @example
+ * snakeCaseKeys({ userName: 'Alice', homeAddress: { zipCode: '12345' } })
+ * // => { user_name: 'Alice', home_address: { zip_code: '12345' } }
+ * @since 3.0.3
+ */
+declare function snakeCaseKeys<T>(value: T): T;
+
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Creates a new object with the same entries as the input, but with its own keys sorted.
+ * Shallow only — nested objects are copied as-is, their keys are not re-sorted.
+ * Key order matters for things like `JSON.stringify` diffs and snapshot stability; this does
+ * not change equality (`{a:1,b:2}` and `{b:2,a:1}` are already equal), just iteration/serialization order.
+ * Note: integer-index-like keys (`"0"`, `"1"`, `"42"`...) are always iterated first, in numeric
+ * order, by the JS engine itself — no object key ordering can override that language behavior.
+ * A prototype-polluting key (`__proto__`, `constructor`, `prototype`) is silently skipped,
+ * same as the rest of `@helpers4/object`.
+ * @param obj - The object whose keys to sort
+ * @param compareFn - Optional custom comparator, passed directly to `Array.prototype.sort`
+ * @returns A new object with the same entries, own keys in sorted order
+ * @example
+ * sortKeys({ b: 2, a: 1, c: 3 })
+ * // => { a: 1, b: 2, c: 3 }
+ * @since 3.0.3
+ */
+declare function sortKeys<T extends Record<string, unknown>>(obj: T, compareFn?: (a: string, b: string) => number): T;
+
+/**
+ * This file is part of helpers4.
+ * Copyright (C) 2025 baxyz
+ * SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+/**
+ * Recursively transforms every key of a plain object (including keys nested inside arrays and
+ * nested objects) to Title Case. Handles camelCase, snake_case, kebab-case, and space-separated
+ * keys. Non-plain-object values — `Date`, `Map`, `Set`, class instances, primitives — are left
+ * untouched, only their position is walked into. An entry whose transformed key is a
+ * prototype-polluting string (`__proto__`, `constructor`, `prototype`) is silently skipped,
+ * same as the rest of `@helpers4/object`.
+ *
+ * Note: unlike the other `*CaseKeys` variants, `titleCase` joins words with spaces (e.g.
+ * `'User Name'`) — those keys are only usable via bracket access (`obj['User Name']`), not dot
+ * notation. Useful for display-facing structures (form labels, table headers), not wire formats.
+ * @param value - The object (or array of objects) to transform
+ * @returns A new value with every plain-object key converted to Title Case
+ * @example
+ * titleCaseKeys({ user_name: 'Alice', home_address: { zip_code: '12345' } })
+ * // => { 'User Name': 'Alice', 'Home Address': { 'Zip Code': '12345' } }
+ * @since 3.0.3
+ */
+declare function titleCaseKeys<T>(value: T): T;
+
 /**
  * This file is part of helpers4.
  * Copyright (C) 2025 baxyz
@@ -927,5 +1100,5 @@ declare function unset<T extends object>(obj: T, path: string | readonly Propert
  */
 declare function update<T extends object, const P extends string | readonly PropertyKey[], V extends DeepGet<T, ParsePath<P>>>(obj: T, path: P, updater: (current: DeepGet<T, ParsePath<P>> | undefined) => V): string extends P ? T : readonly PropertyKey[] extends P ? T : ContainsUnsafeStringKey<ParsePath<P>> extends true ? T : DeepSet<T, ParsePath<P>, V>;
 
-export { clone, cloneDeep, compact, diff, equalsDeep, equalsShallow, flatten, get, groupBy, invert, isEmpty, isNonEmpty, map, mergeDeep, omit, omitBy, parsePropertyPath, pick, pickBy, removeUndefinedNull, safeJsonParse, set, unflatten, unset, update };
+export { camelCaseKeys, clone, cloneDeep, compact, diff, equalsDeep, equalsShallow, flatten, get, groupBy, invert, isEmpty, isNonEmpty, kebabCaseKeys, map, mapDeep, mergeDeep, omit, omitBy, parsePropertyPath, pascalCaseKeys, pick, pickBy, removeUndefinedNull, safeJsonParse, set, snakeCaseKeys, sortKeys, titleCaseKeys, unflatten, unset, update };
 export type { DiffOptions, DiffResult };

package/lib/index.js

@@ -1,9 +1,128 @@
+//#region helpers/string/camelCase.ts
+function camelCase(str) {
+	if (str === void 0 || str === null) return str;
+	const words = str.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean);
+	if (words.length === 0) return "";
+	return words[0].toLowerCase() + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
 var UNSAFE_KEYS = /* @__PURE__ */ new Set([
 	"__proto__",
 	"constructor",
 	"prototype"
 ]);
 //#endregion
+//#region helpers/guard/isPlainObject.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Checks if a value is a plain object.
+*
+* A plain object is created by `{}`, `new Object()`, or `Object.create(null)`.
+* Returns `false` for arrays, Date, Map, Set, RegExp, class instances, etc.
+*
+* @param value - The value to check
+* @returns True if value is a plain object
+* @example
+* isPlainObject({})           // => true
+* isPlainObject({ a: 1 })    // => true
+* isPlainObject(new Date())  // => false
+* isPlainObject([])          // => false
+* isPlainObject(null)        // => false
+* @since 2.0.0
+*/
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+//#endregion
+//#region helpers/object/mapDeep.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+function transform(value, mapValue, mapKey) {
+	if (Array.isArray(value)) return value.map((item, index) => {
+		const recursed = transform(item, mapValue, mapKey);
+		return mapValue ? mapValue(recursed, String(index)) : recursed;
+	});
+	if (isPlainObject(value)) {
+		const result = {};
+		for (const [key, val] of Object.entries(value)) {
+			const newKey = mapKey ? mapKey(key, val) : key;
+			if (typeof newKey === "string" && UNSAFE_KEYS.has(newKey)) continue;
+			const recursed = transform(val, mapValue, mapKey);
+			result[newKey] = mapValue ? mapValue(recursed, key) : recursed;
+		}
+		return result;
+	}
+	return value;
+}
+/**
+* Recursively transforms the keys and/or values of a plain object — the deep counterpart to
+* {@link map}, which only transforms the top level. Descends into nested plain objects and
+* arrays of them; `Date`, `Map`, `Set`, class instances, and primitives are left untouched
+* (only their position is walked into, matching {@link cloneDeep}'s notion of what counts
+* as a plain-data node worth recursing into).
+*
+* Both callbacks are optional and default to identity (no transformation). `mapKey` is called
+* with the *original* key and value (before any recursive value transform); `mapValue` receives
+* the already-recursed value. Entries whose mapped key is a prototype-polluting string
+* (`__proto__`, `constructor`, `prototype`) are silently skipped, same as {@link map}.
+*
+* Array elements also go through `mapValue` (with their stringified index as `key`, since
+* arrays have no property keys of their own) — so values inside a plain array, not just object
+* properties, get transformed too. `mapKey` is never called for array elements, since there is
+* no key to rename.
+*
+* @param obj - The value to transform (typically an object, or an array of objects)
+* @param mapValue - Callback called with `(value, key)` for each entry's (already-recursed) value.
+*   For array elements, `key` is the element's index as a string. Defaults to identity.
+* @param mapKey - Callback called with `(key, value)` for each object entry. Defaults to identity.
+* @returns A new value with every plain-object key/value transformed
+* @example
+* mapDeep({ a: { b: 1 } }, v => (typeof v === 'number' ? v * 10 : v))
+* // => { a: { b: 10 } }
+* @example
+* mapDeep({ user_name: 'Alice' }, undefined, key => key.toUpperCase())
+* // => { USER_NAME: 'Alice' }
+* @example
+* mapDeep({ tags: [1, 2, 3] }, v => (typeof v === 'number' ? v * 10 : v))
+* // => { tags: [10, 20, 30] }
+* @since 3.0.3
+*/
+function mapDeep(obj, mapValue, mapKey) {
+	return transform(obj, mapValue, mapKey);
+}
+//#endregion
+//#region helpers/object/camelCaseKeys.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Recursively transforms every key of a plain object (including keys nested inside arrays and
+* nested objects) to camelCase. Handles snake_case, kebab-case, PascalCase, and space-separated
+* keys. Non-plain-object values (arrays' items aside) — `Date`, `Map`, `Set`, class instances,
+* primitives — are left untouched, only their position is walked into. An entry whose
+* transformed key is a prototype-polluting string (`__proto__`, `constructor`, `prototype`) is
+* silently skipped, same as the rest of `@helpers4/object`.
+* @param value - The object (or array of objects) to transform
+* @returns A new value with every plain-object key converted to camelCase
+* @example
+* camelCaseKeys({ user_name: 'Alice', home_address: { zip_code: '12345' } })
+* // => { userName: 'Alice', homeAddress: { zipCode: '12345' } }
+* @since 3.0.3
+*/
+function camelCaseKeys(value) {
+	return mapDeep(value, void 0, camelCase);
+}
+//#endregion
 //#region helpers/object/clone.ts
 /**
 * This file is part of helpers4.
@@ -98,34 +217,6 @@ function compact(obj) {
 	return result;
 }
 //#endregion
-//#region helpers/guard/isPlainObject.ts
-/**
-* This file is part of helpers4.
-* Copyright (C) 2025 baxyz
-* SPDX-License-Identifier: LGPL-3.0-or-later
-*/
-/**
-* Checks if a value is a plain object.
-*
-* A plain object is created by `{}`, `new Object()`, or `Object.create(null)`.
-* Returns `false` for arrays, Date, Map, Set, RegExp, class instances, etc.
-*
-* @param value - The value to check
-* @returns True if value is a plain object
-* @example
-* isPlainObject({})           // => true
-* isPlainObject({ a: 1 })    // => true
-* isPlainObject(new Date())  // => false
-* isPlainObject([])          // => false
-* isPlainObject(null)        // => false
-* @since 2.0.0
-*/
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object") return false;
-	const proto = Object.getPrototypeOf(value);
-	return proto === Object.prototype || proto === null;
-}
-//#endregion
 //#region helpers/array/equalsDeep.ts
 /**
 * This file is part of helpers4.
@@ -530,6 +621,32 @@ function flatten(obj) {
 	return result;
 }
 //#endregion
+//#region helpers/_shared/_walkPropertyPath.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Walks a value through a sequence of keys, returning the resolved value or `undefined` if any
+* step along the way is missing or not an object. Pure traversal only — string-path parsing
+* (`'a.b.c'` → keys) and default-value substitution are the caller's job.
+*
+* Shared by `object/get.ts` and any `*By`-style accessor elsewhere that needs the same
+* "resolve a path against a value" runtime behavior — kept dependency-free (per the `_shared/`
+* convention) so it can be used from any category without adding a cross-category import for
+* this specific piece.
+* @ignore
+*/
+function walkPropertyPath(value, keys) {
+	let result = value;
+	for (const key of keys) {
+		if (result == null || typeof result !== "object") return;
+		result = result[key];
+	}
+	return result;
+}
+//#endregion
 //#region helpers/object/parsePropertyPath.ts
 /**
 * This file is part of helpers4.
@@ -600,12 +717,7 @@ function parseUncached(path) {
 */
 function get(obj, path, defaultValue) {
 	if (obj == null) return defaultValue;
-	const keys = typeof path === "string" ? parsePropertyPath(path) : path;
-	let result = obj;
-	for (const key of keys) {
-		if (result == null || typeof result !== "object") return defaultValue;
-		result = result[key];
-	}
+	const result = walkPropertyPath(obj, typeof path === "string" ? parsePropertyPath(path) : path);
 	return result !== void 0 ? result : defaultValue;
 }
 //#endregion
@@ -737,6 +849,36 @@ function isNonEmpty(value) {
 	return value != null && Object.keys(value).length > 0;
 }
 //#endregion
+//#region helpers/string/kebabCase.ts
+function kebabCase(str) {
+	if (str === void 0 || str === null) return str;
+	return str.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean).join("-").toLowerCase();
+}
+//#endregion
+//#region helpers/object/kebabCaseKeys.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Recursively transforms every key of a plain object (including keys nested inside arrays and
+* nested objects) to kebab-case. Handles snake_case, camelCase, PascalCase, and space-separated
+* keys. Non-plain-object values — `Date`, `Map`, `Set`, class instances, primitives — are left
+* untouched, only their position is walked into. An entry whose transformed key is a
+* prototype-polluting string (`__proto__`, `constructor`, `prototype`) is silently skipped,
+* same as the rest of `@helpers4/object`.
+* @param value - The object (or array of objects) to transform
+* @returns A new value with every plain-object key converted to kebab-case
+* @example
+* kebabCaseKeys({ userName: 'Alice', homeAddress: { zipCode: '12345' } })
+* // => { 'user-name': 'Alice', 'home-address': { 'zip-code': '12345' } }
+* @since 3.0.3
+*/
+function kebabCaseKeys(value) {
+	return mapDeep(value, void 0, kebabCase);
+}
+//#endregion
 //#region helpers/object/map.ts
 /**
 * This file is part of helpers4.
@@ -850,6 +992,36 @@ function omitBy(obj, predicate) {
 	return result;
 }
 //#endregion
+//#region helpers/string/pascalCase.ts
+function pascalCase(str) {
+	if (str === void 0 || str === null) return str;
+	return str.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+//#endregion
+//#region helpers/object/pascalCaseKeys.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Recursively transforms every key of a plain object (including keys nested inside arrays and
+* nested objects) to PascalCase. Handles camelCase, snake_case, kebab-case, and space-separated
+* keys. Non-plain-object values — `Date`, `Map`, `Set`, class instances, primitives — are left
+* untouched, only their position is walked into. An entry whose transformed key is a
+* prototype-polluting string (`__proto__`, `constructor`, `prototype`) is silently skipped,
+* same as the rest of `@helpers4/object`.
+* @param value - The object (or array of objects) to transform
+* @returns A new value with every plain-object key converted to PascalCase
+* @example
+* pascalCaseKeys({ user_name: 'Alice', home_address: { zip_code: '12345' } })
+* // => { UserName: 'Alice', HomeAddress: { ZipCode: '12345' } }
+* @since 3.0.3
+*/
+function pascalCaseKeys(value) {
+	return mapDeep(value, void 0, pascalCase);
+}
+//#endregion
 //#region helpers/object/pick.ts
 /**
 * This file is part of helpers4.
@@ -971,6 +1143,103 @@ function set(obj, path, value) {
 	return obj;
 }
 //#endregion
+//#region helpers/string/snakeCase.ts
+function snakeCase(str) {
+	if (str === void 0 || str === null) return str;
+	return str.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+//#endregion
+//#region helpers/object/snakeCaseKeys.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Recursively transforms every key of a plain object (including keys nested inside arrays and
+* nested objects) to snake_case. Handles camelCase, PascalCase, kebab-case, and space-separated
+* keys. Non-plain-object values — `Date`, `Map`, `Set`, class instances, primitives — are left
+* untouched, only their position is walked into. An entry whose transformed key is a
+* prototype-polluting string (`__proto__`, `constructor`, `prototype`) is silently skipped,
+* same as the rest of `@helpers4/object`.
+* @param value - The object (or array of objects) to transform
+* @returns A new value with every plain-object key converted to snake_case
+* @example
+* snakeCaseKeys({ userName: 'Alice', homeAddress: { zipCode: '12345' } })
+* // => { user_name: 'Alice', home_address: { zip_code: '12345' } }
+* @since 3.0.3
+*/
+function snakeCaseKeys(value) {
+	return mapDeep(value, void 0, snakeCase);
+}
+//#endregion
+//#region helpers/object/sortKeys.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Creates a new object with the same entries as the input, but with its own keys sorted.
+* Shallow only — nested objects are copied as-is, their keys are not re-sorted.
+* Key order matters for things like `JSON.stringify` diffs and snapshot stability; this does
+* not change equality (`{a:1,b:2}` and `{b:2,a:1}` are already equal), just iteration/serialization order.
+* Note: integer-index-like keys (`"0"`, `"1"`, `"42"`...) are always iterated first, in numeric
+* order, by the JS engine itself — no object key ordering can override that language behavior.
+* A prototype-polluting key (`__proto__`, `constructor`, `prototype`) is silently skipped,
+* same as the rest of `@helpers4/object`.
+* @param obj - The object whose keys to sort
+* @param compareFn - Optional custom comparator, passed directly to `Array.prototype.sort`
+* @returns A new object with the same entries, own keys in sorted order
+* @example
+* sortKeys({ b: 2, a: 1, c: 3 })
+* // => { a: 1, b: 2, c: 3 }
+* @since 3.0.3
+*/
+function sortKeys(obj, compareFn) {
+	const sortedKeys = Object.keys(obj).toSorted(compareFn);
+	const result = {};
+	for (const key of sortedKeys) {
+		if (UNSAFE_KEYS.has(key)) continue;
+		result[key] = obj[key];
+	}
+	return result;
+}
+//#endregion
+//#region helpers/string/titleCase.ts
+function titleCase(str) {
+	if (str === void 0 || str === null) return str;
+	return str.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+//#endregion
+//#region helpers/object/titleCaseKeys.ts
+/**
+* This file is part of helpers4.
+* Copyright (C) 2025 baxyz
+* SPDX-License-Identifier: LGPL-3.0-or-later
+*/
+/**
+* Recursively transforms every key of a plain object (including keys nested inside arrays and
+* nested objects) to Title Case. Handles camelCase, snake_case, kebab-case, and space-separated
+* keys. Non-plain-object values — `Date`, `Map`, `Set`, class instances, primitives — are left
+* untouched, only their position is walked into. An entry whose transformed key is a
+* prototype-polluting string (`__proto__`, `constructor`, `prototype`) is silently skipped,
+* same as the rest of `@helpers4/object`.
+*
+* Note: unlike the other `*CaseKeys` variants, `titleCase` joins words with spaces (e.g.
+* `'User Name'`) — those keys are only usable via bracket access (`obj['User Name']`), not dot
+* notation. Useful for display-facing structures (form labels, table headers), not wire formats.
+* @param value - The object (or array of objects) to transform
+* @returns A new value with every plain-object key converted to Title Case
+* @example
+* titleCaseKeys({ user_name: 'Alice', home_address: { zip_code: '12345' } })
+* // => { 'User Name': 'Alice', 'Home Address': { 'Zip Code': '12345' } }
+* @since 3.0.3
+*/
+function titleCaseKeys(value) {
+	return mapDeep(value, void 0, titleCase);
+}
+//#endregion
 //#region helpers/object/unflatten.ts
 /**
 * This file is part of helpers4.
@@ -1050,6 +1319,6 @@ function update(obj, path, updater) {
 	return set(obj, path, updater(get(obj, path)));
 }
 //#endregion
-export { clone, cloneDeep, compact, diff, equalsDeep, equalsShallow, flatten, get, groupBy, invert, isEmpty, isNonEmpty, map, mergeDeep, omit, omitBy, parsePropertyPath, pick, pickBy, removeUndefinedNull, safeJsonParse, set, unflatten, unset, update };
+export { camelCaseKeys, clone, cloneDeep, compact, diff, equalsDeep, equalsShallow, flatten, get, groupBy, invert, isEmpty, isNonEmpty, kebabCaseKeys, map, mapDeep, mergeDeep, omit, omitBy, parsePropertyPath, pascalCaseKeys, pick, pickBy, removeUndefinedNull, safeJsonParse, set, snakeCaseKeys, sortKeys, titleCaseKeys, unflatten, unset, update };
 
 //# sourceMappingURL=index.js.map