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

package/dist/operations/index.d.ts

@@ -1,144 +1,139 @@
 /*!
- * ====================================================
- * Rzl Utils-JS.
- * ----------------------------------------------------
- * Version: 3.12.0.
- * Author: Rizalvin Dwiky.
- * Repository: https://github.com/rzl-zone/utils-js.
- * ====================================================
- */
-import { NumberRangeUnion } from '@rzl-zone/ts-types-plus';
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  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 { 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;
+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

@@ -1,18 +1,62 @@
 /*!
- * ====================================================
- * Rzl Utils-JS.
- * ----------------------------------------------------
- * Version: 3.12.0.
- * Author: Rizalvin Dwiky.
- * Repository: https://github.com/rzl-zone/utils-js.
- * ====================================================
- */
-export { findDuplicates, omitKeys, omitKeysDeep } from '../chunk-6SCOKU3S.js';
-import '../chunk-YSZC56SZ.js';
-import '../chunk-WYP76WXB.js';
-import '../chunk-SDMPEJ4F.js';
-import '../chunk-HSP6IWZK.js';
-import '../chunk-YWHHVDT4.js';
-import '../chunk-6VUXD3CF.js';
-import '../chunk-QNKGP5DY.js';
-import '../chunk-CSG4SCL3.js';
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  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-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 = [];
+	values.forEach((item, index) => {
+		for (let i = index + 1; i < values.length; i++) if (isEqual(item, values[i])) {
+			if (!duplicates.some((dup) => isEqual(dup, item))) duplicates.push(item);
+			break;
+		}
+	});
+	return duplicates;
+};
+const omitKeys = (object, keysToOmit) => {
+	if (!isPlainObject(object)) return {};
+	assertIsArray(keysToOmit, { message: ({ currentType, validType }) => `Second parameter (\`keysToOmit\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.` });
+	const duplicates = findDuplicates(keysToOmit);
+	if (duplicates.length > 0) throw new Error(`Function "omitKeys" Error: Duplicate keys detected - \`${duplicates}\``);
+	return Object.fromEntries(Object.entries(object).filter(([key]) => !keysToOmit.includes(key)));
+};
+const omitKeysDeep = (object, keysToOmit) => {
+	if (!isPlainObject(object)) return {};
+	assertIsArray(keysToOmit, { message: ({ currentType, validType }) => `Second parameter (\`keysToOmit\`) must be of type \`${validType}\` (array literal or instance), but received: \`${currentType}\`.` });
+	const duplicates = findDuplicates(keysToOmit);
+	if (isNonEmptyArray(duplicates)) throw new Error(`Function "omitKeysDeep" Error: Duplicate keys detected - \`${safeStableStringify(duplicates, { keepUndefined: true })}\`.`);
+	const omitAtPath = (obj, pathParts) => {
+		if (!isObjectOrArray(obj)) return obj;
+		const [current, ...rest] = pathParts;
+		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 = current ? obj[current] : void 0;
+			if (isObjectOrArray(next) && current) obj[current] = omitAtPath(next, rest);
+		}
+		return obj;
+	};
+	const deepRemoveEmptyObjects = (obj) => {
+		if (isArray(obj)) return obj.map(deepRemoveEmptyObjects).filter((item) => !(isObjectOrArray(item) && Object.keys(item).length === 0));
+		if (isObjectOrArray(obj)) return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, deepRemoveEmptyObjects(v)]).filter(([, v]) => !isUndefined(v) && !(isObjectOrArray(v) && Object.keys(v).length === 0)));
+		return obj;
+	};
+	const result = safeJsonParse(safeStableStringify(object));
+	for (const key of keysToOmit) omitAtPath(result, key.split("."));
+	return deepRemoveEmptyObjects(result);
+};
+export { findDuplicates, omitKeys, omitKeysDeep };
+//# sourceMappingURL=index.js.map

package/dist/operations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/operations/findDuplicates.ts","../../src/operations/omitKeys.ts","../../src/operations/omitKeysDeep.ts"],"sourcesContent":["import { isEqual } from \"@/predicates/is/isEqual\";\nimport { assertIsArray } from \"@/assertions/objects/assertIsArray\";\n\n/** ----------------------------------------------------------------------\n * * ***Utility: `findDuplicates`.***\n * ----------------------------------------------------------------------\n * **Finds duplicate values in an array by deep equality comparison.**\n * - **Behavior:**\n *    - Uses ***`isEqual` utility function*** to compare elements\n *      (handles objects, arrays, dates, NaN, etc.).\n *    - Returns a new array containing only the *first occurrences* of duplicated values.\n *    - Does **not mutate** the original array.\n *    - Throws ***{@link TypeError | `TypeError`}*** if input is not an array.\n * @template T Type of elements in the input array.\n * @param {T[]} values - The array to check for duplicates.\n * @returns {T[]} An array of the duplicate values found in the input,\n *                preserving order of their first duplicate appearance.\n * @throws **{@link TypeError | `TypeError`}** if the provided `values` argument is not an array.\n * @example\n * findDuplicates([1, 2, 2, 3, 4, 4]);\n * // ➔ [2, 4]\n * findDuplicates([\"apple\", \"banana\", \"apple\", \"orange\"]);\n * // ➔ [\"apple\"]\n * findDuplicates([{ a: 1 }, { a: 1 }, { a: 2 }]);\n * // ➔ [{ a: 1 }]\n * findDuplicates([NaN, NaN, 1]);\n * // ➔ [NaN]\n * findDuplicates([true, false, true]);\n * // ➔ [true]\n * findDuplicates([1, 2, 3]);\n * // ➔ []\n */\nexport const findDuplicates = <T>(values: T[]): T[] => {\n  assertIsArray(values, {\n    message: ({ currentType, validType }) =>\n      `First parameter (\\`values\\`) must be of type \\`${validType}\\` (array literal or instance), but received: \\`${currentType}\\`.`\n  });\n\n  const duplicates: T[] = [];\n  values.forEach((item, index) => {\n    for (let i = index + 1; i < values.length; i++) {\n      if (isEqual(item, values[i])) {\n        if (!duplicates.some((dup) => isEqual(dup, item))) {\n          duplicates.push(item);\n        }\n        break;\n      }\n    }\n  });\n\n  return duplicates;\n};\n","import { findDuplicates } from \"./findDuplicates\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { assertIsArray } from \"@/assertions/objects/assertIsArray\";\n\n/** --------------------------------\n * * ***Utility: `omitKeys`.***\n * --------------------------------\n * **This function creates a shallow copy of the given object omitting the\n *  specified keys.**\n * - **Behavior:**\n *    - It will return a new object without mutating the original.\n *    - It also validates that ***`keysToOmit`*** does not contain duplicate keys.\n * - **ℹ️ Internally:**\n *    - It uses ***`isEqual`*** to check for duplicates in\n *      the ***`keysToOmit`*** array.\n * @template I The type of the input object.\n * @template K The keys to omit from the object.\n * @param {I} object - The source object to omit keys from.\n * @param {K[]} keysToOmit - An array of keys to exclude from the returned object.\n * @returns {Omit<I, K>} A new object without the specified keys.\n * @throws **{@link TypeError | `TypeError`}** if `keysToOmit` is not an array.\n * @throws **{@link Error | `Error`}** if duplicate keys are found in `keysToOmit`.\n * @example\n * omitKeys({ a: 1, b: 2, c: 3 }, [\"b\", \"c\"]);\n * //➔ { a: 1 }\n * omitKeys({ name: \"John\", age: 30 }, [\"age\"]);\n * //➔ { name: \"John\" }\n * omitKeys({ a: 1, b: 2 }, []);\n * //➔ { a: 1, b: 2 } (no changes)\n */\nexport const omitKeys = <I extends Record<string, unknown>, K extends keyof I>(\n  object: I,\n  keysToOmit: K[]\n): Omit<I, K> => {\n  if (!isPlainObject(object)) return {} as Omit<I, K>;\n\n  assertIsArray(keysToOmit, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`keysToOmit\\`) must be of type \\`${validType}\\` (array literal or instance), but received: \\`${currentType}\\`.`\n  });\n\n  // Check for duplicate keys\n  const duplicates = findDuplicates(keysToOmit);\n  if (duplicates.length > 0) {\n    throw new Error(\n      `Function \"omitKeys\" Error: Duplicate keys detected - \\`${duplicates}\\``\n    );\n  }\n\n  // Remove specified keys\n  return Object.fromEntries(\n    Object.entries(object).filter(([key]) => !keysToOmit.includes(key as K))\n  ) as Omit<I, K>;\n};\n","import type { NumberRangeUnion } from \"@rzl-zone/ts-types-plus\";\n\nimport { findDuplicates } from \"./findDuplicates\";\n\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\nimport { isEmptyArray } from \"@/predicates/is/isEmptyArray\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { isNonEmptyArray } from \"@/predicates/is/isNonEmptyArray\";\nimport { isObjectOrArray } from \"@/predicates/is/isObjectOrArray\";\n\nimport { assertIsArray } from \"@/assertions/objects/assertIsArray\";\n\nimport { safeJsonParse } from \"@/conversions/json/safeJsonParse\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\ntype IndexArray = NumberRangeUnion<0, 30>;\ntype DotPath<T, Prev extends string = \"\"> =\n  T extends Array<infer U>\n    ? DotPath<U, `${Prev}${Prev extends \"\" ? \"\" : \".\"}${IndexArray}`>\n    : T extends object\n      ? {\n          [K in keyof T & string]:\n            | `${Prev}${Prev extends \"\" ? \"\" : \".\"}${K}`\n            | DotPath<T[K], `${Prev}${Prev extends \"\" ? \"\" : \".\"}${K}`>;\n        }[keyof T & string]\n      : never;\n\n/** ------------------------------------------------------\n * * ***Utility: `omitKeysDeep`.***\n * ------------------------------------------------------\n * **Recursively omits properties from an object using dot notation paths.**\n * - **Behavior:**\n *    - Removes resulting empty objects (`{}`) and arrays (`[]`), cascading upwards\n *      to remove empty parents until root if needed.\n * - **⚠️ Be careful:**\n *    - If after omission an object or array becomes empty, it will be removed entirely\n *      including all the way up to the root if necessary, resulting in `{}`.\n * - **ℹ️ Note:**\n *    - For array indices, TypeScript autocomplete only suggests `0`–`30`\n *      (to prevent editor lag on large unions).\n *      However, higher indices are still fully supported at runtime — you can\n *      manually type `\"arr.99.key\"` and it will work the same.\n * @template I - Type of the input object\n * @param {I} object\n *  The object to process, should be a plain nested object or array structure.\n * @param {DotPath<I>[]} keysToOmit\n *  An array of string paths in dot notation indicating the properties to remove, paths\n *  can include numeric indices to target array elements, e.g. `\"arr.0.x\"` to\n *  remove `x` from the first object inside the `arr` array.\n * @returns {Partial<I>}\n *  A new deeply cloned object with the specified keys omitted, with resulting\n *  empty objects or arrays fully removed (even if it collapses to `{}`).\n * @throws **{@link TypeError | `TypeError`}** if `keysToOmit` is not an array.\n * @throws **{@link Error | `Error`}** if `keysToOmit` contains duplicate paths.\n * @example\n * omitKeysDeep({ arr: [{ a: 1 }] }, [\"arr.0.a\"]);\n * // ➔ {} (array becomes empty and removed)\n * omitKeysDeep({ a: { b: { c: 1 }, d: 2 }, e: 3 }, [\"a.b.c\"]);\n * // ➔ { a: { d: 2 }, e: 3 }\n * omitKeysDeep({ a: [{ b: 1 }, { c: 2 }] }, [\"a.0.b\"]);\n * // ➔ { a: [{ c: 2 }] }\n * omitKeysDeep({ a: [{ b: 1 }] }, [\"a.0.b\"]);\n * // ➔ {} (array becomes empty and removed)\n * omitKeysDeep({ complex: [{ deep: [{ x: 1, y: 2 }] }] }, [\"complex.0.deep.0.x\"]);\n * // ➔ { complex: [{ deep: [{ y: 2 }] }] }\n * omitKeysDeep({ complex: [{ deep: [{ x: 1 }] }] }, [\"complex.0.deep.0.x\"]);\n * // ➔ {} (deep chain emptied and collapsed)\n * omitKeysDeep({ data: [[{ foo: 1, bar: 2 }]] }, [\"data.0.0.foo\"]);\n * // ➔ { data: [[{ bar: 2 }]] }\n * omitKeysDeep({ data: [[{ foo: 1 }]] }, [\"data.0.0.foo\"]);\n * // ➔ {} (nested arrays emptied completely)\n * omitKeysDeep({ x: [{ y: [{ z: 1 }, { w: 2 }] }] }, [\"x.0.y.0.z\"]);\n * // ➔ { x: [{ y: [{ w: 2 }] }] }\n * omitKeysDeep({ x: [{ y: [{ z: 1 }] }] }, [\"x.0.y.0.z\"]);\n * // ➔ {} (entire nested arrays removed)\n * omitKeysDeep({ p: { q: { r: 5 } }, s: 6 }, [\"p.q.r\"]);\n * // ➔ { s: 6 } (`p` removed because it becomes empty)\n * omitKeysDeep({ arr: [{ a: 1, b: 2 }, { c: 3 }] }, [\"arr.0.a\"]);\n * // ➔ { arr: [{ b: 2 }, { c: 3 }] }\n * omitKeysDeep({ root: [{ sub: [{ leaf: 10 }] }] }, [\"root.0.sub.0.leaf\"]);\n * // ➔ {} (deep nested arrays emptied to root)\n * omitKeysDeep({ meta: { tags: [\"x\", \"y\"], count: 2 } }, [\"meta.count\"]);\n * // ➔ { meta: { tags: [\"x\", \"y\"] } }\n * omitKeysDeep({ arr: [[{ a: 1 }, { b: 2 }]] }, [\"arr.0.0.a\"]);\n * // ➔ { arr: [[{ b: 2 }]] }\n * omitKeysDeep({ arr: [[{ a: 1 }]] }, [\"arr.0.0.a\"]);\n * // ➔ {} (double nested emptied)\n * omitKeysDeep({ nested: [{ list: [{ id: 1, val: 2 }] }] }, [\"nested.0.list.0.val\"]);\n * // ➔ { nested: [{ list: [{ id: 1 }] }] }\n * omitKeysDeep({ nested: [{ list: [{ id: 1 }] }] }, [\"nested.0.list.0.id\"]);\n * // ➔ {} (full collapse to empty)\n * omitKeysDeep({ mixed: { a: [1, 2, 3], b: { c: 4 } } }, [\"mixed.b.c\"]);\n * // ➔ { mixed: { a: [1, 2, 3] } }\n */\nexport const omitKeysDeep = <I extends Record<string, unknown>>(\n  object: I,\n  keysToOmit: DotPath<I>[]\n): Partial<I> => {\n  if (!isPlainObject(object)) return {} as Partial<I>;\n\n  assertIsArray(keysToOmit, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`keysToOmit\\`) must be of type \\`${validType}\\` (array literal or instance), but received: \\`${currentType}\\`.`\n  });\n\n  const duplicates = findDuplicates(keysToOmit);\n  if (isNonEmptyArray(duplicates)) {\n    throw new Error(\n      `Function \"omitKeysDeep\" Error: Duplicate keys detected - \\`${safeStableStringify(\n        duplicates,\n        {\n          keepUndefined: true\n        }\n      )}\\`.`\n    );\n  }\n\n  const omitAtPath = (obj: unknown, pathParts: string[]) => {\n    if (!isObjectOrArray(obj)) return obj;\n\n    const [current, ...rest] = pathParts;\n\n    if (isEmptyArray(rest) && current) {\n      if (isArray(obj)) {\n        // Support numeric index\n        const index = parseInt(current);\n        if (!isNaN(index) && index in obj) {\n          obj.splice(index, 1);\n        }\n      } else {\n        delete obj[current];\n      }\n    } else {\n      const next = current ? obj[current] : undefined;\n      if (isObjectOrArray(next) && current) {\n        obj[current] = omitAtPath(next, rest);\n      }\n    }\n    return obj;\n  };\n\n  const deepRemoveEmptyObjects = (obj: unknown): unknown => {\n    if (isArray(obj)) {\n      return obj\n        .map(deepRemoveEmptyObjects)\n        .filter(\n          (item) => !(isObjectOrArray(item) && Object.keys(item).length === 0)\n        );\n    }\n    if (isObjectOrArray(obj)) {\n      const cleaned = Object.fromEntries(\n        Object.entries(obj)\n          .map(([k, v]) => [k, deepRemoveEmptyObjects(v)])\n          .filter(\n            ([, v]) =>\n              !isUndefined(v) &&\n              !(isObjectOrArray(v) && Object.keys(v).length === 0)\n          )\n      );\n      return cleaned;\n    }\n    return obj;\n  };\n\n  const result = safeJsonParse(safeStableStringify(object)); // clone deep to avoid mutating original\n  for (const key of keysToOmit) {\n    const parts = key.split(\".\");\n    omitAtPath(result, parts);\n  }\n\n  return deepRemoveEmptyObjects(result) as Partial<I>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,MAAa,kBAAqB,WAAqB;CACrD,cAAc,QAAQ,EACpB,UAAU,EAAE,aAAa,gBACvB,kDAAkD,UAAU,kDAAkD,YAAY,MAC7H,CAAC;CAEF,MAAM,aAAkB,EAAE;CAC1B,OAAO,SAAS,MAAM,UAAU;EAC9B,KAAK,IAAI,IAAI,QAAQ,GAAG,IAAI,OAAO,QAAQ,KACzC,IAAI,QAAQ,MAAM,OAAO,GAAG,EAAE;GAC5B,IAAI,CAAC,WAAW,MAAM,QAAQ,QAAQ,KAAK,KAAK,CAAC,EAC/C,WAAW,KAAK,KAAK;GAEvB;;GAGJ;CAEF,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpBT,MAAa,YACX,QACA,eACe;CACf,IAAI,CAAC,cAAc,OAAO,EAAE,OAAO,EAAE;CAErC,cAAc,YAAY,EACxB,UAAU,EAAE,aAAa,gBACvB,uDAAuD,UAAU,kDAAkD,YAAY,MAClI,CAAC;CAGF,MAAM,aAAa,eAAe,WAAW;CAC7C,IAAI,WAAW,SAAS,GACtB,MAAM,IAAI,MACR,0DAA0D,WAAW,IACtE;CAIH,OAAO,OAAO,YACZ,OAAO,QAAQ,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,WAAW,SAAS,IAAS,CAAC,CACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC4CH,MAAa,gBACX,QACA,eACe;CACf,IAAI,CAAC,cAAc,OAAO,EAAE,OAAO,EAAE;CAErC,cAAc,YAAY,EACxB,UAAU,EAAE,aAAa,gBACvB,uDAAuD,UAAU,kDAAkD,YAAY,MAClI,CAAC;CAEF,MAAM,aAAa,eAAe,WAAW;CAC7C,IAAI,gBAAgB,WAAW,EAC7B,MAAM,IAAI,MACR,8DAA8D,oBAC5D,YACA,EACE,eAAe,MAChB,CACF,CAAC,KACH;CAGH,MAAM,cAAc,KAAc,cAAwB;EACxD,IAAI,CAAC,gBAAgB,IAAI,EAAE,OAAO;EAElC,MAAM,CAAC,SAAS,GAAG,QAAQ;EAE3B,IAAI,aAAa,KAAK,IAAI,SACxB,IAAI,QAAQ,IAAI,EAAE;GAEhB,MAAM,QAAQ,SAAS,QAAQ;GAC/B,IAAI,CAAC,MAAM,MAAM,IAAI,SAAS,KAC5B,IAAI,OAAO,OAAO,EAAE;SAGtB,OAAO,IAAI;OAER;GACL,MAAM,OAAO,UAAU,IAAI,WAAW;GACtC,IAAI,gBAAgB,KAAK,IAAI,SAC3B,IAAI,WAAW,WAAW,MAAM,KAAK;;EAGzC,OAAO;;CAGT,MAAM,0BAA0B,QAA0B;EACxD,IAAI,QAAQ,IAAI,EACd,OAAO,IACJ,IAAI,uBAAuB,CAC3B,QACE,SAAS,EAAE,gBAAgB,KAAK,IAAI,OAAO,KAAK,KAAK,CAAC,WAAW,GACnE;EAEL,IAAI,gBAAgB,IAAI,EAUtB,OATgB,OAAO,YACrB,OAAO,QAAQ,IAAI,CAChB,KAAK,CAAC,GAAG,OAAO,CAAC,GAAG,uBAAuB,EAAE,CAAC,CAAC,CAC/C,QACE,GAAG,OACF,CAAC,YAAY,EAAE,IACf,EAAE,gBAAgB,EAAE,IAAI,OAAO,KAAK,EAAE,CAAC,WAAW,GACrD,CAES;EAEhB,OAAO;;CAGT,MAAM,SAAS,cAAc,oBAAoB,OAAO,CAAC;CACzD,KAAK,MAAM,OAAO,YAEhB,WAAW,QADG,IAAI,MAAM,IACA,CAAC;CAG3B,OAAO,uBAAuB,OAAO"}

package/dist/parsers/index.cjs

@@ -1,20 +1,13 @@
 /*!
- * ====================================================
- * Rzl Utils-JS.
- * ----------------------------------------------------
- * Version: 3.12.0.
- * Author: Rizalvin Dwiky.
- * Repository: https://github.com/rzl-zone/utils-js.
- * ====================================================
- */
-'use strict';
-
-var chunkB4TC6FBV_cjs = require('../chunk-B4TC6FBV.cjs');
-require('../chunk-NYK5K3V2.cjs');
-require('../chunk-YKQEOO7C.cjs');
-require('../chunk-GKC3UDMC.cjs');
-
-Object.defineProperty(exports, "extractFileName", {
-  enumerable: true,
-  get: function () { return chunkB4TC6FBV_cjs.extractFileName; }
-});
+* ========================================================================
+*  @rzl-zone/utils-js
+* ------------------------------------------------------------------------
+*  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`
+* ========================================================================
+*/
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_parsers = require('../parsers-OqDeffqc.cjs');
+exports.extractFileName = require_parsers.extractFileName;