@rzl-zone/utils-js 3.12.1-beta.0 → 3.12.1-beta.1

package/dist/operations/index.d.cts

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
+*  Version: `3.12.1-beta.1`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
@@ -10,130 +10,130 @@
 
 import { NumberRangeUnion } from "@rzl-zone/ts-types-plus";
 /** ----------------------------------------------------------------------
- * * ***Utility: `findDuplicates`.***
- * ----------------------------------------------------------------------
- * **Finds duplicate values in an array by deep equality comparison.**
- * - **Behavior:**
- *    - Uses ***`isEqual` utility function*** to compare elements
- *      (handles objects, arrays, dates, NaN, etc.).
- *    - Returns a new array containing only the *first occurrences* of duplicated values.
- *    - Does **not mutate** the original array.
- *    - Throws ***{@link TypeError | `TypeError`}*** if input is not an array.
- * @template T Type of elements in the input array.
- * @param {T[]} values - The array to check for duplicates.
- * @returns {T[]} An array of the duplicate values found in the input,
- *                preserving order of their first duplicate appearance.
- * @throws **{@link TypeError | `TypeError`}** if the provided `values` argument is not an array.
- * @example
- * findDuplicates([1, 2, 2, 3, 4, 4]);
- * // ➔ [2, 4]
- * findDuplicates(["apple", "banana", "apple", "orange"]);
- * // ➔ ["apple"]
- * findDuplicates([{ a: 1 }, { a: 1 }, { a: 2 }]);
- * // ➔ [{ a: 1 }]
- * findDuplicates([NaN, NaN, 1]);
- * // ➔ [NaN]
- * findDuplicates([true, false, true]);
- * // ➔ [true]
- * findDuplicates([1, 2, 3]);
- * // ➔ []
- */
+* * ***Utility: `findDuplicates`.***
+* ----------------------------------------------------------------------
+* **Finds duplicate values in an array by deep equality comparison.**
+* - **Behavior:**
+*    - Uses ***`isEqual` utility function*** to compare elements
+*      (handles objects, arrays, dates, NaN, etc.).
+*    - Returns a new array containing only the *first occurrences* of duplicated values.
+*    - Does **not mutate** the original array.
+*    - Throws ***{@link TypeError | `TypeError`}*** if input is not an array.
+* @template T Type of elements in the input array.
+* @param {T[]} values - The array to check for duplicates.
+* @returns {T[]} An array of the duplicate values found in the input,
+*                preserving order of their first duplicate appearance.
+* @throws **{@link TypeError | `TypeError`}** if the provided `values` argument is not an array.
+* @example
+* findDuplicates([1, 2, 2, 3, 4, 4]);
+* // ➔ [2, 4]
+* findDuplicates(["apple", "banana", "apple", "orange"]);
+* // ➔ ["apple"]
+* findDuplicates([{ a: 1 }, { a: 1 }, { a: 2 }]);
+* // ➔ [{ a: 1 }]
+* findDuplicates([NaN, NaN, 1]);
+* // ➔ [NaN]
+* findDuplicates([true, false, true]);
+* // ➔ [true]
+* findDuplicates([1, 2, 3]);
+* // ➔ []
+*/
 declare const findDuplicates: <T>(values: T[]) => T[];
 /** --------------------------------
- * * ***Utility: `omitKeys`.***
- * --------------------------------
- * **This function creates a shallow copy of the given object omitting the
- *  specified keys.**
- * - **Behavior:**
- *    - It will return a new object without mutating the original.
- *    - It also validates that ***`keysToOmit`*** does not contain duplicate keys.
- * - **ℹ️ Internally:**
- *    - It uses ***`isEqual`*** to check for duplicates in
- *      the ***`keysToOmit`*** array.
- * @template I The type of the input object.
- * @template K The keys to omit from the object.
- * @param {I} object - The source object to omit keys from.
- * @param {K[]} keysToOmit - An array of keys to exclude from the returned object.
- * @returns {Omit<I, K>} A new object without the specified keys.
- * @throws **{@link TypeError | `TypeError`}** if `keysToOmit` is not an array.
- * @throws **{@link Error | `Error`}** if duplicate keys are found in `keysToOmit`.
- * @example
- * omitKeys({ a: 1, b: 2, c: 3 }, ["b", "c"]);
- * //➔ { a: 1 }
- * omitKeys({ name: "John", age: 30 }, ["age"]);
- * //➔ { name: "John" }
- * omitKeys({ a: 1, b: 2 }, []);
- * //➔ { a: 1, b: 2 } (no changes)
- */
+* * ***Utility: `omitKeys`.***
+* --------------------------------
+* **This function creates a shallow copy of the given object omitting the
+*  specified keys.**
+* - **Behavior:**
+*    - It will return a new object without mutating the original.
+*    - It also validates that ***`keysToOmit`*** does not contain duplicate keys.
+* - **ℹ️ Internally:**
+*    - It uses ***`isEqual`*** to check for duplicates in
+*      the ***`keysToOmit`*** array.
+* @template I The type of the input object.
+* @template K The keys to omit from the object.
+* @param {I} object - The source object to omit keys from.
+* @param {K[]} keysToOmit - An array of keys to exclude from the returned object.
+* @returns {Omit<I, K>} A new object without the specified keys.
+* @throws **{@link TypeError | `TypeError`}** if `keysToOmit` is not an array.
+* @throws **{@link Error | `Error`}** if duplicate keys are found in `keysToOmit`.
+* @example
+* omitKeys({ a: 1, b: 2, c: 3 }, ["b", "c"]);
+* //➔ { a: 1 }
+* omitKeys({ name: "John", age: 30 }, ["age"]);
+* //➔ { name: "John" }
+* omitKeys({ a: 1, b: 2 }, []);
+* //➔ { a: 1, b: 2 } (no changes)
+*/
 declare const omitKeys: <I extends Record<string, unknown>, K extends keyof I>(object: I, keysToOmit: K[]) => Omit<I, K>;
 type IndexArray = NumberRangeUnion<0, 30>;
 type DotPath<T, Prev extends string = ""> = T extends Array<infer U> ? DotPath<U, `${Prev}${Prev extends "" ? "" : "."}${IndexArray}`> : T extends object ? { [K in keyof T & string]: `${Prev}${Prev extends "" ? "" : "."}${K}` | DotPath<T[K], `${Prev}${Prev extends "" ? "" : "."}${K}`> }[keyof T & string] : never;
 /** ------------------------------------------------------
- * * ***Utility: `omitKeysDeep`.***
- * ------------------------------------------------------
- * **Recursively omits properties from an object using dot notation paths.**
- * - **Behavior:**
- *    - Removes resulting empty objects (`{}`) and arrays (`[]`), cascading upwards
- *      to remove empty parents until root if needed.
- * - **⚠️ Be careful:**
- *    - If after omission an object or array becomes empty, it will be removed entirely
- *      including all the way up to the root if necessary, resulting in `{}`.
- * - **ℹ️ Note:**
- *    - For array indices, TypeScript autocomplete only suggests `0`–`30`
- *      (to prevent editor lag on large unions).
- *      However, higher indices are still fully supported at runtime — you can
- *      manually type `"arr.99.key"` and it will work the same.
- * @template I - Type of the input object
- * @param {I} object
- *  The object to process, should be a plain nested object or array structure.
- * @param {DotPath<I>[]} keysToOmit
- *  An array of string paths in dot notation indicating the properties to remove, paths
- *  can include numeric indices to target array elements, e.g. `"arr.0.x"` to
- *  remove `x` from the first object inside the `arr` array.
- * @returns {Partial<I>}
- *  A new deeply cloned object with the specified keys omitted, with resulting
- *  empty objects or arrays fully removed (even if it collapses to `{}`).
- * @throws **{@link TypeError | `TypeError`}** if `keysToOmit` is not an array.
- * @throws **{@link Error | `Error`}** if `keysToOmit` contains duplicate paths.
- * @example
- * omitKeysDeep({ arr: [{ a: 1 }] }, ["arr.0.a"]);
- * // ➔ {} (array becomes empty and removed)
- * omitKeysDeep({ a: { b: { c: 1 }, d: 2 }, e: 3 }, ["a.b.c"]);
- * // ➔ { a: { d: 2 }, e: 3 }
- * omitKeysDeep({ a: [{ b: 1 }, { c: 2 }] }, ["a.0.b"]);
- * // ➔ { a: [{ c: 2 }] }
- * omitKeysDeep({ a: [{ b: 1 }] }, ["a.0.b"]);
- * // ➔ {} (array becomes empty and removed)
- * omitKeysDeep({ complex: [{ deep: [{ x: 1, y: 2 }] }] }, ["complex.0.deep.0.x"]);
- * // ➔ { complex: [{ deep: [{ y: 2 }] }] }
- * omitKeysDeep({ complex: [{ deep: [{ x: 1 }] }] }, ["complex.0.deep.0.x"]);
- * // ➔ {} (deep chain emptied and collapsed)
- * omitKeysDeep({ data: [[{ foo: 1, bar: 2 }]] }, ["data.0.0.foo"]);
- * // ➔ { data: [[{ bar: 2 }]] }
- * omitKeysDeep({ data: [[{ foo: 1 }]] }, ["data.0.0.foo"]);
- * // ➔ {} (nested arrays emptied completely)
- * omitKeysDeep({ x: [{ y: [{ z: 1 }, { w: 2 }] }] }, ["x.0.y.0.z"]);
- * // ➔ { x: [{ y: [{ w: 2 }] }] }
- * omitKeysDeep({ x: [{ y: [{ z: 1 }] }] }, ["x.0.y.0.z"]);
- * // ➔ {} (entire nested arrays removed)
- * omitKeysDeep({ p: { q: { r: 5 } }, s: 6 }, ["p.q.r"]);
- * // ➔ { s: 6 } (`p` removed because it becomes empty)
- * omitKeysDeep({ arr: [{ a: 1, b: 2 }, { c: 3 }] }, ["arr.0.a"]);
- * // ➔ { arr: [{ b: 2 }, { c: 3 }] }
- * omitKeysDeep({ root: [{ sub: [{ leaf: 10 }] }] }, ["root.0.sub.0.leaf"]);
- * // ➔ {} (deep nested arrays emptied to root)
- * omitKeysDeep({ meta: { tags: ["x", "y"], count: 2 } }, ["meta.count"]);
- * // ➔ { meta: { tags: ["x", "y"] } }
- * omitKeysDeep({ arr: [[{ a: 1 }, { b: 2 }]] }, ["arr.0.0.a"]);
- * // ➔ { arr: [[{ b: 2 }]] }
- * omitKeysDeep({ arr: [[{ a: 1 }]] }, ["arr.0.0.a"]);
- * // ➔ {} (double nested emptied)
- * omitKeysDeep({ nested: [{ list: [{ id: 1, val: 2 }] }] }, ["nested.0.list.0.val"]);
- * // ➔ { nested: [{ list: [{ id: 1 }] }] }
- * omitKeysDeep({ nested: [{ list: [{ id: 1 }] }] }, ["nested.0.list.0.id"]);
- * // ➔ {} (full collapse to empty)
- * omitKeysDeep({ mixed: { a: [1, 2, 3], b: { c: 4 } } }, ["mixed.b.c"]);
- * // ➔ { mixed: { a: [1, 2, 3] } }
- */
+* * ***Utility: `omitKeysDeep`.***
+* ------------------------------------------------------
+* **Recursively omits properties from an object using dot notation paths.**
+* - **Behavior:**
+*    - Removes resulting empty objects (`{}`) and arrays (`[]`), cascading upwards
+*      to remove empty parents until root if needed.
+* - **⚠️ Be careful:**
+*    - If after omission an object or array becomes empty, it will be removed entirely
+*      including all the way up to the root if necessary, resulting in `{}`.
+* - **ℹ️ Note:**
+*    - For array indices, TypeScript autocomplete only suggests `0`–`30`
+*      (to prevent editor lag on large unions).
+*      However, higher indices are still fully supported at runtime — you can
+*      manually type `"arr.99.key"` and it will work the same.
+* @template I - Type of the input object
+* @param {I} object
+*  The object to process, should be a plain nested object or array structure.
+* @param {DotPath<I>[]} keysToOmit
+*  An array of string paths in dot notation indicating the properties to remove, paths
+*  can include numeric indices to target array elements, e.g. `"arr.0.x"` to
+*  remove `x` from the first object inside the `arr` array.
+* @returns {Partial<I>}
+*  A new deeply cloned object with the specified keys omitted, with resulting
+*  empty objects or arrays fully removed (even if it collapses to `{}`).
+* @throws **{@link TypeError | `TypeError`}** if `keysToOmit` is not an array.
+* @throws **{@link Error | `Error`}** if `keysToOmit` contains duplicate paths.
+* @example
+* omitKeysDeep({ arr: [{ a: 1 }] }, ["arr.0.a"]);
+* // ➔ {} (array becomes empty and removed)
+* omitKeysDeep({ a: { b: { c: 1 }, d: 2 }, e: 3 }, ["a.b.c"]);
+* // ➔ { a: { d: 2 }, e: 3 }
+* omitKeysDeep({ a: [{ b: 1 }, { c: 2 }] }, ["a.0.b"]);
+* // ➔ { a: [{ c: 2 }] }
+* omitKeysDeep({ a: [{ b: 1 }] }, ["a.0.b"]);
+* // ➔ {} (array becomes empty and removed)
+* omitKeysDeep({ complex: [{ deep: [{ x: 1, y: 2 }] }] }, ["complex.0.deep.0.x"]);
+* // ➔ { complex: [{ deep: [{ y: 2 }] }] }
+* omitKeysDeep({ complex: [{ deep: [{ x: 1 }] }] }, ["complex.0.deep.0.x"]);
+* // ➔ {} (deep chain emptied and collapsed)
+* omitKeysDeep({ data: [[{ foo: 1, bar: 2 }]] }, ["data.0.0.foo"]);
+* // ➔ { data: [[{ bar: 2 }]] }
+* omitKeysDeep({ data: [[{ foo: 1 }]] }, ["data.0.0.foo"]);
+* // ➔ {} (nested arrays emptied completely)
+* omitKeysDeep({ x: [{ y: [{ z: 1 }, { w: 2 }] }] }, ["x.0.y.0.z"]);
+* // ➔ { x: [{ y: [{ w: 2 }] }] }
+* omitKeysDeep({ x: [{ y: [{ z: 1 }] }] }, ["x.0.y.0.z"]);
+* // ➔ {} (entire nested arrays removed)
+* omitKeysDeep({ p: { q: { r: 5 } }, s: 6 }, ["p.q.r"]);
+* // ➔ { s: 6 } (`p` removed because it becomes empty)
+* omitKeysDeep({ arr: [{ a: 1, b: 2 }, { c: 3 }] }, ["arr.0.a"]);
+* // ➔ { arr: [{ b: 2 }, { c: 3 }] }
+* omitKeysDeep({ root: [{ sub: [{ leaf: 10 }] }] }, ["root.0.sub.0.leaf"]);
+* // ➔ {} (deep nested arrays emptied to root)
+* omitKeysDeep({ meta: { tags: ["x", "y"], count: 2 } }, ["meta.count"]);
+* // ➔ { meta: { tags: ["x", "y"] } }
+* omitKeysDeep({ arr: [[{ a: 1 }, { b: 2 }]] }, ["arr.0.0.a"]);
+* // ➔ { arr: [[{ b: 2 }]] }
+* omitKeysDeep({ arr: [[{ a: 1 }]] }, ["arr.0.0.a"]);
+* // ➔ {} (double nested emptied)
+* omitKeysDeep({ nested: [{ list: [{ id: 1, val: 2 }] }] }, ["nested.0.list.0.val"]);
+* // ➔ { nested: [{ list: [{ id: 1 }] }] }
+* omitKeysDeep({ nested: [{ list: [{ id: 1 }] }] }, ["nested.0.list.0.id"]);
+* // ➔ {} (full collapse to empty)
+* omitKeysDeep({ mixed: { a: [1, 2, 3], b: { c: 4 } } }, ["mixed.b.c"]);
+* // ➔ { mixed: { a: [1, 2, 3] } }
+*/
 declare const omitKeysDeep: <I extends Record<string, unknown>>(object: I, keysToOmit: DotPath<I>[]) => Partial<I>;
 export { findDuplicates, omitKeys, omitKeysDeep };

package/dist/operations/index.d.ts

@@ -2,7 +2,7 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
+*  Version: `3.12.1-beta.1`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
@@ -10,130 +10,130 @@
 
 import { NumberRangeUnion } from "@rzl-zone/ts-types-plus";
 /** ----------------------------------------------------------------------
- * * ***Utility: `findDuplicates`.***
- * ----------------------------------------------------------------------
- * **Finds duplicate values in an array by deep equality comparison.**
- * - **Behavior:**
- *    - Uses ***`isEqual` utility function*** to compare elements
- *      (handles objects, arrays, dates, NaN, etc.).
- *    - Returns a new array containing only the *first occurrences* of duplicated values.
- *    - Does **not mutate** the original array.
- *    - Throws ***{@link TypeError | `TypeError`}*** if input is not an array.
- * @template T Type of elements in the input array.
- * @param {T[]} values - The array to check for duplicates.
- * @returns {T[]} An array of the duplicate values found in the input,
- *                preserving order of their first duplicate appearance.
- * @throws **{@link TypeError | `TypeError`}** if the provided `values` argument is not an array.
- * @example
- * findDuplicates([1, 2, 2, 3, 4, 4]);
- * // ➔ [2, 4]
- * findDuplicates(["apple", "banana", "apple", "orange"]);
- * // ➔ ["apple"]
- * findDuplicates([{ a: 1 }, { a: 1 }, { a: 2 }]);
- * // ➔ [{ a: 1 }]
- * findDuplicates([NaN, NaN, 1]);
- * // ➔ [NaN]
- * findDuplicates([true, false, true]);
- * // ➔ [true]
- * findDuplicates([1, 2, 3]);
- * // ➔ []
- */
+* * ***Utility: `findDuplicates`.***
+* ----------------------------------------------------------------------
+* **Finds duplicate values in an array by deep equality comparison.**
+* - **Behavior:**
+*    - Uses ***`isEqual` utility function*** to compare elements
+*      (handles objects, arrays, dates, NaN, etc.).
+*    - Returns a new array containing only the *first occurrences* of duplicated values.
+*    - Does **not mutate** the original array.
+*    - Throws ***{@link TypeError | `TypeError`}*** if input is not an array.
+* @template T Type of elements in the input array.
+* @param {T[]} values - The array to check for duplicates.
+* @returns {T[]} An array of the duplicate values found in the input,
+*                preserving order of their first duplicate appearance.
+* @throws **{@link TypeError | `TypeError`}** if the provided `values` argument is not an array.
+* @example
+* findDuplicates([1, 2, 2, 3, 4, 4]);
+* // ➔ [2, 4]
+* findDuplicates(["apple", "banana", "apple", "orange"]);
+* // ➔ ["apple"]
+* findDuplicates([{ a: 1 }, { a: 1 }, { a: 2 }]);
+* // ➔ [{ a: 1 }]
+* findDuplicates([NaN, NaN, 1]);
+* // ➔ [NaN]
+* findDuplicates([true, false, true]);
+* // ➔ [true]
+* findDuplicates([1, 2, 3]);
+* // ➔ []
+*/
 declare const findDuplicates: <T>(values: T[]) => T[];
 /** --------------------------------
- * * ***Utility: `omitKeys`.***
- * --------------------------------
- * **This function creates a shallow copy of the given object omitting the
- *  specified keys.**
- * - **Behavior:**
- *    - It will return a new object without mutating the original.
- *    - It also validates that ***`keysToOmit`*** does not contain duplicate keys.
- * - **ℹ️ Internally:**
- *    - It uses ***`isEqual`*** to check for duplicates in
- *      the ***`keysToOmit`*** array.
- * @template I The type of the input object.
- * @template K The keys to omit from the object.
- * @param {I} object - The source object to omit keys from.
- * @param {K[]} keysToOmit - An array of keys to exclude from the returned object.
- * @returns {Omit<I, K>} A new object without the specified keys.
- * @throws **{@link TypeError | `TypeError`}** if `keysToOmit` is not an array.
- * @throws **{@link Error | `Error`}** if duplicate keys are found in `keysToOmit`.
- * @example
- * omitKeys({ a: 1, b: 2, c: 3 }, ["b", "c"]);
- * //➔ { a: 1 }
- * omitKeys({ name: "John", age: 30 }, ["age"]);
- * //➔ { name: "John" }
- * omitKeys({ a: 1, b: 2 }, []);
- * //➔ { a: 1, b: 2 } (no changes)
- */
+* * ***Utility: `omitKeys`.***
+* --------------------------------
+* **This function creates a shallow copy of the given object omitting the
+*  specified keys.**
+* - **Behavior:**
+*    - It will return a new object without mutating the original.
+*    - It also validates that ***`keysToOmit`*** does not contain duplicate keys.
+* - **ℹ️ Internally:**
+*    - It uses ***`isEqual`*** to check for duplicates in
+*      the ***`keysToOmit`*** array.
+* @template I The type of the input object.
+* @template K The keys to omit from the object.
+* @param {I} object - The source object to omit keys from.
+* @param {K[]} keysToOmit - An array of keys to exclude from the returned object.
+* @returns {Omit<I, K>} A new object without the specified keys.
+* @throws **{@link TypeError | `TypeError`}** if `keysToOmit` is not an array.
+* @throws **{@link Error | `Error`}** if duplicate keys are found in `keysToOmit`.
+* @example
+* omitKeys({ a: 1, b: 2, c: 3 }, ["b", "c"]);
+* //➔ { a: 1 }
+* omitKeys({ name: "John", age: 30 }, ["age"]);
+* //➔ { name: "John" }
+* omitKeys({ a: 1, b: 2 }, []);
+* //➔ { a: 1, b: 2 } (no changes)
+*/
 declare const omitKeys: <I extends Record<string, unknown>, K extends keyof I>(object: I, keysToOmit: K[]) => Omit<I, K>;
 type IndexArray = NumberRangeUnion<0, 30>;
 type DotPath<T, Prev extends string = ""> = T extends Array<infer U> ? DotPath<U, `${Prev}${Prev extends "" ? "" : "."}${IndexArray}`> : T extends object ? { [K in keyof T & string]: `${Prev}${Prev extends "" ? "" : "."}${K}` | DotPath<T[K], `${Prev}${Prev extends "" ? "" : "."}${K}`> }[keyof T & string] : never;
 /** ------------------------------------------------------
- * * ***Utility: `omitKeysDeep`.***
- * ------------------------------------------------------
- * **Recursively omits properties from an object using dot notation paths.**
- * - **Behavior:**
- *    - Removes resulting empty objects (`{}`) and arrays (`[]`), cascading upwards
- *      to remove empty parents until root if needed.
- * - **⚠️ Be careful:**
- *    - If after omission an object or array becomes empty, it will be removed entirely
- *      including all the way up to the root if necessary, resulting in `{}`.
- * - **ℹ️ Note:**
- *    - For array indices, TypeScript autocomplete only suggests `0`–`30`
- *      (to prevent editor lag on large unions).
- *      However, higher indices are still fully supported at runtime — you can
- *      manually type `"arr.99.key"` and it will work the same.
- * @template I - Type of the input object
- * @param {I} object
- *  The object to process, should be a plain nested object or array structure.
- * @param {DotPath<I>[]} keysToOmit
- *  An array of string paths in dot notation indicating the properties to remove, paths
- *  can include numeric indices to target array elements, e.g. `"arr.0.x"` to
- *  remove `x` from the first object inside the `arr` array.
- * @returns {Partial<I>}
- *  A new deeply cloned object with the specified keys omitted, with resulting
- *  empty objects or arrays fully removed (even if it collapses to `{}`).
- * @throws **{@link TypeError | `TypeError`}** if `keysToOmit` is not an array.
- * @throws **{@link Error | `Error`}** if `keysToOmit` contains duplicate paths.
- * @example
- * omitKeysDeep({ arr: [{ a: 1 }] }, ["arr.0.a"]);
- * // ➔ {} (array becomes empty and removed)
- * omitKeysDeep({ a: { b: { c: 1 }, d: 2 }, e: 3 }, ["a.b.c"]);
- * // ➔ { a: { d: 2 }, e: 3 }
- * omitKeysDeep({ a: [{ b: 1 }, { c: 2 }] }, ["a.0.b"]);
- * // ➔ { a: [{ c: 2 }] }
- * omitKeysDeep({ a: [{ b: 1 }] }, ["a.0.b"]);
- * // ➔ {} (array becomes empty and removed)
- * omitKeysDeep({ complex: [{ deep: [{ x: 1, y: 2 }] }] }, ["complex.0.deep.0.x"]);
- * // ➔ { complex: [{ deep: [{ y: 2 }] }] }
- * omitKeysDeep({ complex: [{ deep: [{ x: 1 }] }] }, ["complex.0.deep.0.x"]);
- * // ➔ {} (deep chain emptied and collapsed)
- * omitKeysDeep({ data: [[{ foo: 1, bar: 2 }]] }, ["data.0.0.foo"]);
- * // ➔ { data: [[{ bar: 2 }]] }
- * omitKeysDeep({ data: [[{ foo: 1 }]] }, ["data.0.0.foo"]);
- * // ➔ {} (nested arrays emptied completely)
- * omitKeysDeep({ x: [{ y: [{ z: 1 }, { w: 2 }] }] }, ["x.0.y.0.z"]);
- * // ➔ { x: [{ y: [{ w: 2 }] }] }
- * omitKeysDeep({ x: [{ y: [{ z: 1 }] }] }, ["x.0.y.0.z"]);
- * // ➔ {} (entire nested arrays removed)
- * omitKeysDeep({ p: { q: { r: 5 } }, s: 6 }, ["p.q.r"]);
- * // ➔ { s: 6 } (`p` removed because it becomes empty)
- * omitKeysDeep({ arr: [{ a: 1, b: 2 }, { c: 3 }] }, ["arr.0.a"]);
- * // ➔ { arr: [{ b: 2 }, { c: 3 }] }
- * omitKeysDeep({ root: [{ sub: [{ leaf: 10 }] }] }, ["root.0.sub.0.leaf"]);
- * // ➔ {} (deep nested arrays emptied to root)
- * omitKeysDeep({ meta: { tags: ["x", "y"], count: 2 } }, ["meta.count"]);
- * // ➔ { meta: { tags: ["x", "y"] } }
- * omitKeysDeep({ arr: [[{ a: 1 }, { b: 2 }]] }, ["arr.0.0.a"]);
- * // ➔ { arr: [[{ b: 2 }]] }
- * omitKeysDeep({ arr: [[{ a: 1 }]] }, ["arr.0.0.a"]);
- * // ➔ {} (double nested emptied)
- * omitKeysDeep({ nested: [{ list: [{ id: 1, val: 2 }] }] }, ["nested.0.list.0.val"]);
- * // ➔ { nested: [{ list: [{ id: 1 }] }] }
- * omitKeysDeep({ nested: [{ list: [{ id: 1 }] }] }, ["nested.0.list.0.id"]);
- * // ➔ {} (full collapse to empty)
- * omitKeysDeep({ mixed: { a: [1, 2, 3], b: { c: 4 } } }, ["mixed.b.c"]);
- * // ➔ { mixed: { a: [1, 2, 3] } }
- */
+* * ***Utility: `omitKeysDeep`.***
+* ------------------------------------------------------
+* **Recursively omits properties from an object using dot notation paths.**
+* - **Behavior:**
+*    - Removes resulting empty objects (`{}`) and arrays (`[]`), cascading upwards
+*      to remove empty parents until root if needed.
+* - **⚠️ Be careful:**
+*    - If after omission an object or array becomes empty, it will be removed entirely
+*      including all the way up to the root if necessary, resulting in `{}`.
+* - **ℹ️ Note:**
+*    - For array indices, TypeScript autocomplete only suggests `0`–`30`
+*      (to prevent editor lag on large unions).
+*      However, higher indices are still fully supported at runtime — you can
+*      manually type `"arr.99.key"` and it will work the same.
+* @template I - Type of the input object
+* @param {I} object
+*  The object to process, should be a plain nested object or array structure.
+* @param {DotPath<I>[]} keysToOmit
+*  An array of string paths in dot notation indicating the properties to remove, paths
+*  can include numeric indices to target array elements, e.g. `"arr.0.x"` to
+*  remove `x` from the first object inside the `arr` array.
+* @returns {Partial<I>}
+*  A new deeply cloned object with the specified keys omitted, with resulting
+*  empty objects or arrays fully removed (even if it collapses to `{}`).
+* @throws **{@link TypeError | `TypeError`}** if `keysToOmit` is not an array.
+* @throws **{@link Error | `Error`}** if `keysToOmit` contains duplicate paths.
+* @example
+* omitKeysDeep({ arr: [{ a: 1 }] }, ["arr.0.a"]);
+* // ➔ {} (array becomes empty and removed)
+* omitKeysDeep({ a: { b: { c: 1 }, d: 2 }, e: 3 }, ["a.b.c"]);
+* // ➔ { a: { d: 2 }, e: 3 }
+* omitKeysDeep({ a: [{ b: 1 }, { c: 2 }] }, ["a.0.b"]);
+* // ➔ { a: [{ c: 2 }] }
+* omitKeysDeep({ a: [{ b: 1 }] }, ["a.0.b"]);
+* // ➔ {} (array becomes empty and removed)
+* omitKeysDeep({ complex: [{ deep: [{ x: 1, y: 2 }] }] }, ["complex.0.deep.0.x"]);
+* // ➔ { complex: [{ deep: [{ y: 2 }] }] }
+* omitKeysDeep({ complex: [{ deep: [{ x: 1 }] }] }, ["complex.0.deep.0.x"]);
+* // ➔ {} (deep chain emptied and collapsed)
+* omitKeysDeep({ data: [[{ foo: 1, bar: 2 }]] }, ["data.0.0.foo"]);
+* // ➔ { data: [[{ bar: 2 }]] }
+* omitKeysDeep({ data: [[{ foo: 1 }]] }, ["data.0.0.foo"]);
+* // ➔ {} (nested arrays emptied completely)
+* omitKeysDeep({ x: [{ y: [{ z: 1 }, { w: 2 }] }] }, ["x.0.y.0.z"]);
+* // ➔ { x: [{ y: [{ w: 2 }] }] }
+* omitKeysDeep({ x: [{ y: [{ z: 1 }] }] }, ["x.0.y.0.z"]);
+* // ➔ {} (entire nested arrays removed)
+* omitKeysDeep({ p: { q: { r: 5 } }, s: 6 }, ["p.q.r"]);
+* // ➔ { s: 6 } (`p` removed because it becomes empty)
+* omitKeysDeep({ arr: [{ a: 1, b: 2 }, { c: 3 }] }, ["arr.0.a"]);
+* // ➔ { arr: [{ b: 2 }, { c: 3 }] }
+* omitKeysDeep({ root: [{ sub: [{ leaf: 10 }] }] }, ["root.0.sub.0.leaf"]);
+* // ➔ {} (deep nested arrays emptied to root)
+* omitKeysDeep({ meta: { tags: ["x", "y"], count: 2 } }, ["meta.count"]);
+* // ➔ { meta: { tags: ["x", "y"] } }
+* omitKeysDeep({ arr: [[{ a: 1 }, { b: 2 }]] }, ["arr.0.0.a"]);
+* // ➔ { arr: [[{ b: 2 }]] }
+* omitKeysDeep({ arr: [[{ a: 1 }]] }, ["arr.0.0.a"]);
+* // ➔ {} (double nested emptied)
+* omitKeysDeep({ nested: [{ list: [{ id: 1, val: 2 }] }] }, ["nested.0.list.0.val"]);
+* // ➔ { nested: [{ list: [{ id: 1 }] }] }
+* omitKeysDeep({ nested: [{ list: [{ id: 1 }] }] }, ["nested.0.list.0.id"]);
+* // ➔ {} (full collapse to empty)
+* omitKeysDeep({ mixed: { a: [1, 2, 3], b: { c: 4 } } }, ["mixed.b.c"]);
+* // ➔ { mixed: { a: [1, 2, 3] } }
+*/
 declare const omitKeysDeep: <I extends Record<string, unknown>>(object: I, keysToOmit: DotPath<I>[]) => Partial<I>;
 export { findDuplicates, omitKeys, omitKeysDeep };

package/dist/operations/index.js

@@ -2,17 +2,17 @@
 * ========================================================================
 *  @rzl-zone/utils-js
 * ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
+*  Version: `3.12.1-beta.1`
 *  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
 *  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
 * ========================================================================
 */
-import { A as isPlainObject, D as isNaN, M as isArray, S as isUndefined, p as isNonEmptyArray, x as isObjectOrArray } from "../assertIsBoolean-BlBct0Fc.js";
-import { t as assertIsArray } from "../assertIsArray-BfAbIUfa.js";
-import { n as isEmptyArray } from "../isEmptyObject-DeLVIJpl.js";
-import { t as safeStableStringify } from "../safeStableStringify-BNh3D0K0.js";
-import { t as isEqual } from "../isEqual-DhyP8fB_.js";
-import { t as safeJsonParse } from "../safeJsonParse-CXruaP0p.js";
+import { A as isPlainObject, D as isNaN, M as isArray, S as isUndefined, p as isNonEmptyArray, x as isObjectOrArray } from "../assertIsBoolean-DR1SaXPD.js";
+import { t as assertIsArray } from "../assertIsArray-bTA3XLjq.js";
+import { n as isEmptyArray } from "../isEmptyObject-DCipFwxJ.js";
+import { t as safeStableStringify } from "../safeStableStringify-CXOZ9Ub8.js";
+import { t as isEqual } from "../isEqual-BX49cF9m.js";
+import { t as safeJsonParse } from "../safeJsonParse-BP38mwlj.js";
 const findDuplicates = (values) => {
 	assertIsArray(values, { message: ({ currentType, validType }) => `First parameter (\`values\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.` });
 	const duplicates = [];
@@ -39,13 +39,13 @@ const omitKeysDeep = (object, keysToOmit) => {
 	const omitAtPath = (obj, pathParts) => {
 		if (!isObjectOrArray(obj)) return obj;
 		const [current, ...rest] = pathParts;
-		if (isEmptyArray(rest)) if (isArray(obj)) {
+		if (isEmptyArray(rest) && current) if (isArray(obj)) {
 			const index = parseInt(current);
 			if (!isNaN(index) && index in obj) obj.splice(index, 1);
 		} else delete obj[current];
 		else {
-			const next = obj[current];
-			if (isObjectOrArray(next)) obj[current] = omitAtPath(next, rest);
+			const next = current ? obj[current] : void 0;
+			if (isObjectOrArray(next) && current) obj[current] = omitAtPath(next, rest);
 		}
 		return obj;
 	};