@cyberskill/shared 3.2.0 → 3.3.0

package/dist/util/common/common.util.js

@@ -1,54 +1,125 @@
-import { E_Environment as o } from "../../typescript/common.type.js";
-const p = {
-  a: ["à", "á", "ạ", "ả", "ã", "â", "ầ", "ấ", "ậ", "ẩ", "ẫ", "ă", "ằ", "ắ", "ặ", "ẳ", "ẵ"],
-  e: ["è", "é", "ẹ", "ẻ", "ẽ", "ê", "ề", "ế", "ệ", "ể", "ễ"],
-  i: ["ì", "í", "ị", "ỉ", "ĩ"],
-  o: ["ò", "ó", "ọ", "ỏ", "õ", "ô", "ồ", "ố", "ộ", "ổ", "ỗ", "ơ", "ờ", "ớ", "ợ", "ở", "ỡ"],
-  u: ["ù", "ú", "ụ", "ủ", "ũ", "ư", "ừ", "ứ", "ự", "ử", "ữ"],
-  y: ["ỳ", "ý", "ỵ", "ỷ", "ỹ"],
-  d: ["đ"]
-}, a = Object.entries(p).reduce(
-  (e, [n, t]) => (e[n.toUpperCase()] = t.map((r) => r.toUpperCase()), e),
-  {}
-), u = { ...p, ...a }, s = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set();
-Object.entries(u).forEach(([e, n]) => {
-  const t = `(${[e, ...n].join("|")})`;
-  [e, ...n].forEach((r) => {
-    s.set(r, t), i.add(r);
-  });
+import { E_Environment as e } from "../../typescript/common.type.js";
+//#region src/util/common/common.util.ts
+var t = {
+	a: [
+		"à",
+		"á",
+		"ạ",
+		"ả",
+		"ã",
+		"â",
+		"ầ",
+		"ấ",
+		"ậ",
+		"ẩ",
+		"ẫ",
+		"ă",
+		"ằ",
+		"ắ",
+		"ặ",
+		"ẳ",
+		"ẵ"
+	],
+	e: [
+		"è",
+		"é",
+		"ẹ",
+		"ẻ",
+		"ẽ",
+		"ê",
+		"ề",
+		"ế",
+		"ệ",
+		"ể",
+		"ễ"
+	],
+	i: [
+		"ì",
+		"í",
+		"ị",
+		"ỉ",
+		"ĩ"
+	],
+	o: [
+		"ò",
+		"ó",
+		"ọ",
+		"ỏ",
+		"õ",
+		"ô",
+		"ồ",
+		"ố",
+		"ộ",
+		"ổ",
+		"ỗ",
+		"ơ",
+		"ờ",
+		"ớ",
+		"ợ",
+		"ở",
+		"ỡ"
+	],
+	u: [
+		"ù",
+		"ú",
+		"ụ",
+		"ủ",
+		"ũ",
+		"ư",
+		"ừ",
+		"ứ",
+		"ự",
+		"ử",
+		"ữ"
+	],
+	y: [
+		"ỳ",
+		"ý",
+		"ỵ",
+		"ỷ",
+		"ỹ"
+	],
+	d: ["đ"]
+}, n = Object.entries(t).reduce((e, [t, n]) => (e[t.toUpperCase()] = n.map((e) => e.toUpperCase()), e), {}), r = {
+	...t,
+	...n
+}, i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Set();
+Object.entries(r).forEach(([e, t]) => {
+	let n = `(${[e, ...t].join("|")})`;
+	[e, ...t].forEach((e) => {
+		i.set(e, n), a.add(e);
+	});
 });
-const O = [...i].join(""), D = new RegExp(`[${O}]`, "g"), N = /[.*+?^${}()|[\]\\]/g;
-function M(e) {
-  return e.replace(N, "\\$&");
+var o = [...a].join(""), s = RegExp(`[${o}]`, "g"), c = /[.*+?^${}()|[\]\\]/g;
+function l(e) {
+	return e.replace(c, "\\$&");
 }
-function m(e) {
-  return e = M(e), e.replace(D, (n) => s.get(n) || n);
+function u(e) {
+	return e = l(e), e.replace(s, (e) => i.get(e) || e);
 }
-const f = /\p{Diacritic}/gu;
-function P(e) {
-  return e.normalize("NFD").replace(f, "");
+var d = /\p{Diacritic}/gu;
+function f(e) {
+	return e.normalize("NFD").replace(d, "");
 }
-function R(e, n) {
-  if (!n)
-    return [...new Set(e)];
-  const t = /* @__PURE__ */ new Set(), r = [];
-  for (const c of e) {
-    const E = n(c);
-    t.has(E) || (t.add(E), r.push(c));
-  }
-  return r;
+function p(e, t) {
+	if (!t) return [...new Set(e)];
+	let n = /* @__PURE__ */ new Set(), r = [];
+	for (let i of e) {
+		let e = t(i);
+		n.has(e) || (n.add(e), r.push(i));
+	}
+	return r;
 }
-function _(e) {
-  const { NODE_ENV: n = o.DEVELOPMENT, NODE_ENV_MODE: t = o.DEVELOPMENT } = e, r = n === o.DEVELOPMENT && t === o.DEVELOPMENT, c = n === o.PRODUCTION && t === o.STAGING, E = n === o.PRODUCTION && t === o.PRODUCTION;
-  if (n === o.PRODUCTION && t === o.DEVELOPMENT)
-    throw new Error("NODE_ENV_MODE must be set to staging or production in production environment");
-  return { IS_DEV: r, IS_STAG: c, IS_PROD: E };
+function m(t) {
+	let { NODE_ENV: n = e.DEVELOPMENT, NODE_ENV_MODE: r = e.DEVELOPMENT } = t, i = n === e.DEVELOPMENT && r === e.DEVELOPMENT, a = n === e.PRODUCTION && r === e.STAGING, o = n === e.PRODUCTION && r === e.PRODUCTION;
+	if (n === e.PRODUCTION && r === e.DEVELOPMENT) throw Error("NODE_ENV_MODE must be set to staging or production in production environment");
+	return {
+		IS_DEV: i,
+		IS_STAG: a,
+		IS_PROD: o
+	};
 }
-export {
-  M as escapeRegExp,
-  _ as mapEnvironment,
-  m as regexSearchMapper,
-  P as removeAccent,
-  R as uniqueArray
-};
-//# sourceMappingURL=common.util.js.map
+//#endregion
+export { l as escapeRegExp, m as mapEnvironment, u as regexSearchMapper, f as removeAccent, p as uniqueArray };
+
+//# sourceMappingURL=common.util.js.map

package/dist/util/common/common.util.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.util.js","sources":["../../../src/util/common/common.util.ts"],"sourcesContent":["import { E_Environment } from '#typescript/index.js';\n\nimport type { I_EnvFlags, I_NodeEnvInput } from './common.type.js';\n\nconst charMap: Record<string, string[]> = {\n    a: ['à', 'á', 'ạ', 'ả', 'ã', 'â', 'ầ', 'ấ', 'ậ', 'ẩ', 'ẫ', 'ă', 'ằ', 'ắ', 'ặ', 'ẳ', 'ẵ'],\n    e: ['è', 'é', 'ẹ', 'ẻ', 'ẽ', 'ê', 'ề', 'ế', 'ệ', 'ể', 'ễ'],\n    i: ['ì', 'í', 'ị', 'ỉ', 'ĩ'],\n    o: ['ò', 'ó', 'ọ', 'ỏ', 'õ', 'ô', 'ồ', 'ố', 'ộ', 'ổ', 'ỗ', 'ơ', 'ờ', 'ớ', 'ợ', 'ở', 'ỡ'],\n    u: ['ù', 'ú', 'ụ', 'ủ', 'ũ', 'ư', 'ừ', 'ứ', 'ự', 'ử', 'ữ'],\n    y: ['ỳ', 'ý', 'ỵ', 'ỷ', 'ỹ'],\n    d: ['đ'],\n};\n\nconst upperCharMap: Record<string, string[]> = Object.entries(charMap).reduce(\n    (map, [key, value]) => {\n        map[key.toUpperCase()] = value.map(char => char.toUpperCase());\n        return map;\n    },\n    {} as Record<string, string[]>,\n);\n\nconst combinedMap = { ...charMap, ...upperCharMap };\n\n// Pre-compute replacement map and search regex for better performance\n// This avoids rebuilding regexes and maps on every function call\nconst replacementMap = new Map<string, string>();\nconst charsToMatch = new Set<string>();\n\nObject.entries(combinedMap).forEach(([baseChar, variations]) => {\n    // The replacement pattern is the same for the base char and all its variations\n    // Example: 'a', 'à', 'á'... all map to '(a|à|á...)'\n    const replacement = `(${[baseChar, ...variations].join('|')})`;\n\n    [baseChar, ...variations].forEach((char) => {\n        replacementMap.set(char, replacement);\n        charsToMatch.add(char);\n    });\n});\n\n// Construct a single regex that matches any character in our map\nconst patternString = [...charsToMatch].join('');\n// We use a character class regex: [abc...]\n// eslint-disable-next-line regexp/no-empty-character-class -- regex is built dynamically from precomputed charMap\nconst searchRegex = new RegExp(`[${patternString}]`, 'g');\n\nconst RE_ESCAPE_REGEXP = /[.*+?^${}()|[\\]\\\\]/g;\n\n/**\n * Escapes special characters in a string for use in a regular expression.\n * This function escapes characters that have special meaning in regex (e.g., ., *, +, ?, etc.)\n * so they are treated as literal characters.\n *\n * @param str - The string to escape.\n * @returns The escaped string safe for use in a RegExp.\n */\nexport function escapeRegExp(str: string): string {\n    return str.replace(RE_ESCAPE_REGEXP, '\\\\$&');\n}\n\n/**\n * Convert a string to a regex pattern that matches the string and its accented variations.\n * This function normalizes the input string and creates a regex pattern that can match\n * both the original characters and their accented equivalents.\n *\n * Optimization: Uses pre-computed regex and map to perform replacement in a single pass (O(N)),\n * instead of iterating through all character groups (O(K*N)).\n * Removed unnecessary NFD normalization which improves performance and fixes\n * matching against NFC target strings.\n *\n * @param str - The string to convert to a regex pattern.\n * @returns The regex pattern as a string that matches the original string and its accented variations.\n */\nexport function regexSearchMapper(str: string) {\n    str = escapeRegExp(str);\n    return str.replace(searchRegex, match => replacementMap.get(match) || match);\n}\n\nconst RE_DIACRITIC = /\\p{Diacritic}/gu;\n\n/**\n * Remove accents from a string.\n * This function normalizes the string using NFD normalization and removes all diacritical marks.\n *\n * @param str - The string to remove accents from.\n * @returns The string without any accents or diacritical marks.\n */\nexport function removeAccent(str: string) {\n    return str.normalize('NFD').replace(RE_DIACRITIC, '');\n}\n\n/**\n * Remove duplicates from an array based on a key function.\n * This function can remove duplicates either by comparing values directly (when no keyFn is provided)\n * or by using a custom key function to determine uniqueness.\n *\n * @param arr - The array to remove duplicates from.\n * @param keyFn - Optional function that returns a unique key for each item in the array.\n * @returns A new array with duplicates removed, maintaining the original order.\n */\nexport function uniqueArray<T>(\n    arr: T[],\n    keyFn?: (item: T) => string | number,\n): T[] {\n    if (!keyFn) {\n        return [...new Set(arr)];\n    }\n\n    const seen = new Set<string | number>();\n    const result: T[] = [];\n\n    for (const item of arr) {\n        const key = keyFn(item);\n        if (!seen.has(key)) {\n            seen.add(key);\n            result.push(item);\n        }\n    }\n\n    return result;\n}\n\n/**\n * Map environment variables to boolean flags indicating the current environment.\n * This function takes NODE_ENV and NODE_ENV_MODE variables and returns flags\n * indicating whether the current environment is development, staging, or production.\n *\n * @param env - The environment variables object containing NODE_ENV and NODE_ENV_MODE.\n * @returns An object containing boolean flags for the environment (IS_DEV, IS_STAG, IS_PROD).\n * @throws {Error} When NODE_ENV is production but NODE_ENV_MODE is development.\n */\nexport function mapEnvironment(env: I_NodeEnvInput): I_EnvFlags {\n    const { NODE_ENV = E_Environment.DEVELOPMENT, NODE_ENV_MODE = E_Environment.DEVELOPMENT } = env;\n\n    const IS_DEV = NODE_ENV === E_Environment.DEVELOPMENT && NODE_ENV_MODE === E_Environment.DEVELOPMENT;\n    const IS_STAG = NODE_ENV === E_Environment.PRODUCTION && NODE_ENV_MODE === E_Environment.STAGING;\n    const IS_PROD = NODE_ENV === E_Environment.PRODUCTION && NODE_ENV_MODE === E_Environment.PRODUCTION;\n\n    if (NODE_ENV === E_Environment.PRODUCTION && NODE_ENV_MODE === E_Environment.DEVELOPMENT) {\n        throw new Error('NODE_ENV_MODE must be set to staging or production in production environment');\n    }\n\n    return { IS_DEV, IS_STAG, IS_PROD };\n}\n"],"names":["E_Environment","charMap","upperCharMap","map","key","value","char","combinedMap","replacementMap","charsToMatch","baseChar","variations","replacement","patternString","searchRegex","RE_ESCAPE_REGEXP","escapeRegExp","str","regexSearchMapper","match","RE_DIACRITIC","removeAccent","uniqueArray","arr","keyFn","seen","result","item","mapEnvironment","env","NODE_ENV","NODE_ENV_MODE","IS_DEV","IS_STAG","IS_PROD"],"mappings":"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"}
+{"version":3,"file":"common.util.js","names":[],"sources":["../../../src/util/common/common.util.ts"],"sourcesContent":["import { E_Environment } from '#typescript/index.js';\n\nimport type { I_EnvFlags, I_NodeEnvInput } from './common.type.js';\n\nconst charMap: Record<string, string[]> = {\n    a: ['à', 'á', 'ạ', 'ả', 'ã', 'â', 'ầ', 'ấ', 'ậ', 'ẩ', 'ẫ', 'ă', 'ằ', 'ắ', 'ặ', 'ẳ', 'ẵ'],\n    e: ['è', 'é', 'ẹ', 'ẻ', 'ẽ', 'ê', 'ề', 'ế', 'ệ', 'ể', 'ễ'],\n    i: ['ì', 'í', 'ị', 'ỉ', 'ĩ'],\n    o: ['ò', 'ó', 'ọ', 'ỏ', 'õ', 'ô', 'ồ', 'ố', 'ộ', 'ổ', 'ỗ', 'ơ', 'ờ', 'ớ', 'ợ', 'ở', 'ỡ'],\n    u: ['ù', 'ú', 'ụ', 'ủ', 'ũ', 'ư', 'ừ', 'ứ', 'ự', 'ử', 'ữ'],\n    y: ['ỳ', 'ý', 'ỵ', 'ỷ', 'ỹ'],\n    d: ['đ'],\n};\n\nconst upperCharMap: Record<string, string[]> = Object.entries(charMap).reduce(\n    (map, [key, value]) => {\n        map[key.toUpperCase()] = value.map(char => char.toUpperCase());\n        return map;\n    },\n    {} as Record<string, string[]>,\n);\n\nconst combinedMap = { ...charMap, ...upperCharMap };\n\n// Pre-compute replacement map and search regex for better performance\n// This avoids rebuilding regexes and maps on every function call\nconst replacementMap = new Map<string, string>();\nconst charsToMatch = new Set<string>();\n\nObject.entries(combinedMap).forEach(([baseChar, variations]) => {\n    // The replacement pattern is the same for the base char and all its variations\n    // Example: 'a', 'à', 'á'... all map to '(a|à|á...)'\n    const replacement = `(${[baseChar, ...variations].join('|')})`;\n\n    [baseChar, ...variations].forEach((char) => {\n        replacementMap.set(char, replacement);\n        charsToMatch.add(char);\n    });\n});\n\n// Construct a single regex that matches any character in our map\nconst patternString = [...charsToMatch].join('');\n// We use a character class regex: [abc...]\n// eslint-disable-next-line regexp/no-empty-character-class -- regex is built dynamically from precomputed charMap\nconst searchRegex = new RegExp(`[${patternString}]`, 'g');\n\nconst RE_ESCAPE_REGEXP = /[.*+?^${}()|[\\]\\\\]/g;\n\n/**\n * Escapes special characters in a string for use in a regular expression.\n * This function escapes characters that have special meaning in regex (e.g., ., *, +, ?, etc.)\n * so they are treated as literal characters.\n *\n * @param str - The string to escape.\n * @returns The escaped string safe for use in a RegExp.\n */\nexport function escapeRegExp(str: string): string {\n    return str.replace(RE_ESCAPE_REGEXP, '\\\\$&');\n}\n\n/**\n * Convert a string to a regex pattern that matches the string and its accented variations.\n * This function normalizes the input string and creates a regex pattern that can match\n * both the original characters and their accented equivalents.\n *\n * Optimization: Uses pre-computed regex and map to perform replacement in a single pass (O(N)),\n * instead of iterating through all character groups (O(K*N)).\n * Removed unnecessary NFD normalization which improves performance and fixes\n * matching against NFC target strings.\n *\n * @param str - The string to convert to a regex pattern.\n * @returns The regex pattern as a string that matches the original string and its accented variations.\n */\nexport function regexSearchMapper(str: string) {\n    str = escapeRegExp(str);\n    return str.replace(searchRegex, match => replacementMap.get(match) || match);\n}\n\nconst RE_DIACRITIC = /\\p{Diacritic}/gu;\n\n/**\n * Remove accents from a string.\n * This function normalizes the string using NFD normalization and removes all diacritical marks.\n *\n * @param str - The string to remove accents from.\n * @returns The string without any accents or diacritical marks.\n */\nexport function removeAccent(str: string) {\n    return str.normalize('NFD').replace(RE_DIACRITIC, '');\n}\n\n/**\n * Remove duplicates from an array based on a key function.\n * This function can remove duplicates either by comparing values directly (when no keyFn is provided)\n * or by using a custom key function to determine uniqueness.\n *\n * @param arr - The array to remove duplicates from.\n * @param keyFn - Optional function that returns a unique key for each item in the array.\n * @returns A new array with duplicates removed, maintaining the original order.\n */\nexport function uniqueArray<T>(\n    arr: T[],\n    keyFn?: (item: T) => string | number,\n): T[] {\n    if (!keyFn) {\n        return [...new Set(arr)];\n    }\n\n    const seen = new Set<string | number>();\n    const result: T[] = [];\n\n    for (const item of arr) {\n        const key = keyFn(item);\n        if (!seen.has(key)) {\n            seen.add(key);\n            result.push(item);\n        }\n    }\n\n    return result;\n}\n\n/**\n * Map environment variables to boolean flags indicating the current environment.\n * This function takes NODE_ENV and NODE_ENV_MODE variables and returns flags\n * indicating whether the current environment is development, staging, or production.\n *\n * @param env - The environment variables object containing NODE_ENV and NODE_ENV_MODE.\n * @returns An object containing boolean flags for the environment (IS_DEV, IS_STAG, IS_PROD).\n * @throws {Error} When NODE_ENV is production but NODE_ENV_MODE is development.\n */\nexport function mapEnvironment(env: I_NodeEnvInput): I_EnvFlags {\n    const { NODE_ENV = E_Environment.DEVELOPMENT, NODE_ENV_MODE = E_Environment.DEVELOPMENT } = env;\n\n    const IS_DEV = NODE_ENV === E_Environment.DEVELOPMENT && NODE_ENV_MODE === E_Environment.DEVELOPMENT;\n    const IS_STAG = NODE_ENV === E_Environment.PRODUCTION && NODE_ENV_MODE === E_Environment.STAGING;\n    const IS_PROD = NODE_ENV === E_Environment.PRODUCTION && NODE_ENV_MODE === E_Environment.PRODUCTION;\n\n    if (NODE_ENV === E_Environment.PRODUCTION && NODE_ENV_MODE === E_Environment.DEVELOPMENT) {\n        throw new Error('NODE_ENV_MODE must be set to staging or production in production environment');\n    }\n\n    return { IS_DEV, IS_STAG, IS_PROD };\n}\n"],"mappings":";;AAIA,IAAM,IAAoC;CACtC,GAAG;EAAC;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAI;CACxF,GAAG;EAAC;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAI;CAC1D,GAAG;EAAC;EAAK;EAAK;EAAK;EAAK;EAAI;CAC5B,GAAG;EAAC;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAI;CACxF,GAAG;EAAC;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAK;EAAI;CAC1D,GAAG;EAAC;EAAK;EAAK;EAAK;EAAK;EAAI;CAC5B,GAAG,CAAC,IAAI;CACX,EAEK,IAAyC,OAAO,QAAQ,EAAQ,CAAC,QAClE,GAAK,CAAC,GAAK,QACR,EAAI,EAAI,aAAa,IAAI,EAAM,KAAI,MAAQ,EAAK,aAAa,CAAC,EACvD,IAEX,EAAE,CACL,EAEK,IAAc;CAAE,GAAG;CAAS,GAAG;CAAc,EAI7C,oBAAiB,IAAI,KAAqB,EAC1C,oBAAe,IAAI,KAAa;AAEtC,OAAO,QAAQ,EAAY,CAAC,SAAS,CAAC,GAAU,OAAgB;CAG5D,IAAM,IAAc,IAAI,CAAC,GAAU,GAAG,EAAW,CAAC,KAAK,IAAI,CAAC;AAE5D,EAAC,GAAU,GAAG,EAAW,CAAC,SAAS,MAAS;AAExC,EADA,EAAe,IAAI,GAAM,EAAY,EACrC,EAAa,IAAI,EAAK;GACxB;EACJ;AAGF,IAAM,IAAgB,CAAC,GAAG,EAAa,CAAC,KAAK,GAAG,EAG1C,IAAkB,OAAO,IAAI,EAAc,IAAI,IAAI,EAEnD,IAAmB;AAUzB,SAAgB,EAAa,GAAqB;AAC9C,QAAO,EAAI,QAAQ,GAAkB,OAAO;;AAgBhD,SAAgB,EAAkB,GAAa;AAE3C,QADA,IAAM,EAAa,EAAI,EAChB,EAAI,QAAQ,IAAa,MAAS,EAAe,IAAI,EAAM,IAAI,EAAM;;AAGhF,IAAM,IAAe;AASrB,SAAgB,EAAa,GAAa;AACtC,QAAO,EAAI,UAAU,MAAM,CAAC,QAAQ,GAAc,GAAG;;AAYzD,SAAgB,EACZ,GACA,GACG;AACH,KAAI,CAAC,EACD,QAAO,CAAC,GAAG,IAAI,IAAI,EAAI,CAAC;CAG5B,IAAM,oBAAO,IAAI,KAAsB,EACjC,IAAc,EAAE;AAEtB,MAAK,IAAM,KAAQ,GAAK;EACpB,IAAM,IAAM,EAAM,EAAK;AACvB,EAAK,EAAK,IAAI,EAAI,KACd,EAAK,IAAI,EAAI,EACb,EAAO,KAAK,EAAK;;AAIzB,QAAO;;AAYX,SAAgB,EAAe,GAAiC;CAC5D,IAAM,EAAE,cAAW,EAAc,aAAa,mBAAgB,EAAc,gBAAgB,GAEtF,IAAS,MAAa,EAAc,eAAe,MAAkB,EAAc,aACnF,IAAU,MAAa,EAAc,cAAc,MAAkB,EAAc,SACnF,IAAU,MAAa,EAAc,cAAc,MAAkB,EAAc;AAEzF,KAAI,MAAa,EAAc,cAAc,MAAkB,EAAc,YACzE,OAAU,MAAM,+EAA+E;AAGnG,QAAO;EAAE;EAAQ;EAAS;EAAS"}

package/dist/util/common/index.js

@@ -1,9 +1,2 @@
-import { escapeRegExp as p, mapEnvironment as a, regexSearchMapper as n, removeAccent as c, uniqueArray as m } from "./common.util.js";
-export {
-  p as escapeRegExp,
-  a as mapEnvironment,
-  n as regexSearchMapper,
-  c as removeAccent,
-  m as uniqueArray
-};
-//# sourceMappingURL=index.js.map
+import { escapeRegExp as e, mapEnvironment as t, regexSearchMapper as n, removeAccent as r, uniqueArray as i } from "./common.util.js";
+export { e as escapeRegExp, t as mapEnvironment, n as regexSearchMapper, r as removeAccent, i as uniqueArray };

package/dist/util/index.js

@@ -1,27 +1,6 @@
-import { deepClone as t, deepMerge as o, getNestedValue as a, isJSON as n, normalizeMongoFilter as g, setNestedValue as m } from "./object/object.util.js";
-import { escapeRegExp as i, mapEnvironment as s, regexSearchMapper as d, removeAccent as l, uniqueArray as x } from "./common/common.util.js";
-import { generateRandomPassword as f, generateRandomString as S, generateShortId as c, generateSlug as N, getFileName as v, substringBetween as M } from "./string/string.util.js";
-import { serializer as h } from "./serializer/serializer.util.js";
-import { validate as z } from "./validate/validate.util.js";
-export {
-  t as deepClone,
-  o as deepMerge,
-  i as escapeRegExp,
-  f as generateRandomPassword,
-  S as generateRandomString,
-  c as generateShortId,
-  N as generateSlug,
-  v as getFileName,
-  a as getNestedValue,
-  n as isJSON,
-  s as mapEnvironment,
-  g as normalizeMongoFilter,
-  d as regexSearchMapper,
-  l as removeAccent,
-  h as serializer,
-  m as setNestedValue,
-  M as substringBetween,
-  x as uniqueArray,
-  z as validate
-};
-//# sourceMappingURL=index.js.map
+import { escapeRegExp as e, mapEnvironment as t, regexSearchMapper as n, removeAccent as r, uniqueArray as i } from "./common/common.util.js";
+import { deepClone as a, deepMerge as o, getNestedValue as s, isJSON as c, normalizeMongoFilter as l, setNestedValue as u } from "./object/object.util.js";
+import { serializer as d } from "./serializer/serializer.util.js";
+import { generateRandomPassword as f, generateRandomString as p, generateShortId as m, generateSlug as h, getFileName as g, substringBetween as _ } from "./string/string.util.js";
+import { validate as v } from "./validate/validate.util.js";
+export { a as deepClone, o as deepMerge, e as escapeRegExp, f as generateRandomPassword, p as generateRandomString, m as generateShortId, h as generateSlug, g as getFileName, s as getNestedValue, c as isJSON, t as mapEnvironment, l as normalizeMongoFilter, n as regexSearchMapper, r as removeAccent, d as serializer, u as setNestedValue, _ as substringBetween, i as uniqueArray, v as validate };

package/dist/util/object/index.d.ts

@@ -1 +1,4 @@
+/**
+ * Re-exports all object manipulation utilities.
+ */
 export * from './object.util.js';

package/dist/util/object/index.js

@@ -1,10 +1,2 @@
-import { deepClone as t, deepMerge as l, getNestedValue as r, isJSON as d, normalizeMongoFilter as s, setNestedValue as a } from "./object.util.js";
-export {
-  t as deepClone,
-  l as deepMerge,
-  r as getNestedValue,
-  d as isJSON,
-  s as normalizeMongoFilter,
-  a as setNestedValue
-};
-//# sourceMappingURL=index.js.map
+import { deepClone as e, deepMerge as t, getNestedValue as n, isJSON as r, normalizeMongoFilter as i, setNestedValue as a } from "./object.util.js";
+export { e as deepClone, t as deepMerge, n as getNestedValue, r as isJSON, i as normalizeMongoFilter, a as setNestedValue };

package/dist/util/object/object.util.js

@@ -1,135 +1,101 @@
-function A(e) {
-  try {
-    return JSON.parse(e), !0;
-  } catch {
-    return !1;
-  }
+//#region src/util/object/object.util.ts
+function e(e) {
+	try {
+		return JSON.parse(e), !0;
+	} catch {
+		return !1;
+	}
 }
-function p(e, t) {
-  let n = e;
-  const s = t.length;
-  for (let r = 0; r < s; r++) {
-    if (n == null || typeof n != "object")
-      return;
-    const o = t[r];
-    if (o !== void 0 && o in n)
-      n = n[o];
-    else
-      return;
-  }
-  return n;
+function t(e, t) {
+	let n = e, r = t.length;
+	for (let e = 0; e < r; e++) {
+		if (typeof n != "object" || !n) return;
+		let r = t[e];
+		if (r !== void 0 && r in n) n = n[r];
+		else return;
+	}
+	return n;
 }
-function c(e, t, n, s) {
-  if (s >= t.length)
-    return e;
-  const r = t[s];
-  if (s === t.length - 1)
-    return {
-      ...e,
-      [r]: n
-    };
-  const o = e[r];
-  return {
-    ...e,
-    [r]: c(
-      typeof o == "object" && o !== null ? o : {},
-      t,
-      n,
-      s + 1
-    )
-  };
+function n(e, t, r, i) {
+	if (i >= t.length) return e;
+	let a = t[i];
+	if (i === t.length - 1) return {
+		...e,
+		[a]: r
+	};
+	let o = e[a];
+	return {
+		...e,
+		[a]: n(typeof o == "object" && o ? o : {}, t, r, i + 1)
+	};
 }
-function g(e, t, n) {
-  return t.length === 0 ? e : c(e, t, n, 0);
+function r(e, t, r) {
+	return t.length === 0 ? e : n(e, t, r, 0);
 }
-function f(e) {
-  if (e === null || typeof e != "object")
-    return e;
-  if (Array.isArray(e))
-    return e.map((s) => f(s));
-  if (e instanceof Date)
-    return new Date(e.getTime());
-  if (e instanceof RegExp)
-    return new RegExp(e.source, e.flags);
-  const t = Object.getPrototypeOf(e);
-  if (t !== Object.prototype && t !== null)
-    return e;
-  const n = {};
-  for (const s in e)
-    Object.hasOwn(e, s) && (n[s] = f(e[s]));
-  return n;
+function i(e) {
+	if (typeof e != "object" || !e) return e;
+	if (e instanceof Date) return new Date(e.getTime());
+	if (e instanceof RegExp) return new RegExp(e.source, e.flags);
+	if (Array.isArray(e)) {
+		let t = e.length, n = Array(t);
+		for (let r = 0; r < t; r++) n[r] = i(e[r]);
+		return n;
+	}
+	let t = Object.getPrototypeOf(e);
+	if (t !== Object.prototype && t !== null) return e;
+	let n = {};
+	for (let t in e) Object.hasOwn(e, t) && (n[t] = i(e[t]));
+	return n;
 }
-function y(...e) {
-  if (e.length === 0)
-    return {};
-  const t = e.filter((r) => r != null);
-  if (t.length === 0)
-    return {};
-  if (t.length === 1)
-    return t[0];
-  if (t.every(Array.isArray))
-    return t.flat();
-  if (t.every((r) => typeof r == "object" && r !== null && !Array.isArray(r))) {
-    const r = {};
-    for (const o of t) {
-      const l = o;
-      for (const i in l)
-        if (Object.hasOwn(l, i)) {
-          const u = l[i];
-          if (Object.hasOwn(r, i)) {
-            const a = r[i];
-            typeof u == "object" && u !== null && typeof a == "object" && a !== null ? Array.isArray(u) && Array.isArray(a) ? r[i] = [...a, ...u] : !Array.isArray(u) && !Array.isArray(a) ? r[i] = y(
-              a,
-              u
-            ) : r[i] = u : r[i] = u;
-          } else
-            r[i] = u;
-        }
-    }
-    return r;
-  }
-  if (t.every((r) => typeof r != "object" || r === null))
-    throw new Error(
-      "deepMerge: Cannot merge primitive values. All arguments must be objects or arrays."
-    );
-  const n = t.some(Array.isArray), s = t.some(
-    (r) => typeof r == "object" && r !== null && !Array.isArray(r)
-  );
-  throw n && s ? new Error(
-    "deepMerge: Cannot mix arrays and objects. All arguments must be either arrays or objects."
-  ) : new Error(
-    "deepMerge: Invalid arguments provided. All arguments must be objects or arrays of the same type."
-  );
+function a(...e) {
+	if (e.length === 0) return {};
+	let t = e.filter((e) => e != null);
+	if (t.length === 0) return {};
+	if (t.length === 1) return t[0];
+	if (t.every(Array.isArray)) return t.flat();
+	if (t.every((e) => typeof e == "object" && !!e && !Array.isArray(e))) {
+		let e = {};
+		for (let n of t) {
+			let t = n;
+			for (let n in t) if (Object.hasOwn(t, n)) {
+				let r = t[n];
+				if (Object.hasOwn(e, n)) {
+					let t = e[n];
+					typeof r == "object" && r && typeof t == "object" && t ? Array.isArray(r) && Array.isArray(t) ? e[n] = [...t, ...r] : !Array.isArray(r) && !Array.isArray(t) ? e[n] = a(t, r) : e[n] = r : e[n] = r;
+				} else e[n] = r;
+			}
+		}
+		return e;
+	}
+	if (t.every((e) => typeof e != "object" || !e)) throw Error("deepMerge: Cannot merge primitive values. All arguments must be objects or arrays.");
+	let n = t.some(Array.isArray), r = t.some((e) => typeof e == "object" && !!e && !Array.isArray(e));
+	throw Error(n && r ? "deepMerge: Cannot mix arrays and objects. All arguments must be either arrays or objects." : "deepMerge: Invalid arguments provided. All arguments must be objects or arrays of the same type.");
 }
-function h(e) {
-  if (!e || typeof e != "object")
-    return e;
-  const t = {};
-  function n(s, r) {
-    for (const o in s) {
-      if (!Object.hasOwn(s, o))
-        continue;
-      const l = s[o], i = r ? `${r}.${o}` : o;
-      if (l && typeof l == "object" && !Array.isArray(l)) {
-        let u = !1;
-        for (const a in l)
-          if (Object.hasOwn(l, a) && a.startsWith("$")) {
-            u = !0;
-            break;
-          }
-        u ? t[i] = l : n(l, i);
-      } else
-        t[i] = l;
-    }
-  }
-  return n(e, ""), t;
+function o(e) {
+	if (!e || typeof e != "object") return e;
+	let t = {};
+	function n(e, r) {
+		for (let i in e) {
+			if (!Object.hasOwn(e, i)) continue;
+			let a = e[i], o = r ? `${r}.${i}` : i;
+			if (a && typeof a == "object" && !Array.isArray(a)) {
+				let e = Object.getPrototypeOf(a);
+				if (e !== Object.prototype && e !== null) {
+					t[o] = a;
+					continue;
+				}
+				let r = !1;
+				for (let e in a) if (Object.hasOwn(a, e) && e.startsWith("$")) {
+					r = !0;
+					break;
+				}
+				r ? t[o] = a : n(a, o);
+			} else t[o] = a;
+		}
+	}
+	return n(e, ""), t;
 }
-export {
-  f as deepClone,
-  y as deepMerge,
-  p as getNestedValue,
-  A as isJSON,
-  h as normalizeMongoFilter,
-  g as setNestedValue
-};
-//# sourceMappingURL=object.util.js.map
+//#endregion
+export { i as deepClone, a as deepMerge, t as getNestedValue, e as isJSON, o as normalizeMongoFilter, r as setNestedValue };
+
+//# sourceMappingURL=object.util.js.map

package/dist/util/object/object.util.js.map

@@ -1 +1 @@
-{"version":3,"file":"object.util.js","sources":["../../../src/util/object/object.util.ts"],"sourcesContent":["/**\n * Check if a string is a valid JSON string.\n * This function attempts to parse the string as JSON and returns true if successful,\n * false if the string is not valid JSON.\n *\n * @param str - The string to check for valid JSON format.\n * @returns True if the string is a valid JSON string, false otherwise.\n */\nexport function isJSON(str: string): boolean {\n    try {\n        JSON.parse(str);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n\n/**\n * Gets a nested value from an object using a path array.\n * This function traverses the object following the provided path and returns\n * the value at the specified location, or undefined if the path doesn't exist.\n *\n * @param obj - The object to get the value from.\n * @param path - An array of keys representing the path to the desired value.\n * @returns The value at the specified path, or undefined if the path doesn't exist.\n */\nexport function getNestedValue<T>(obj: T, path: (string | number)[]): unknown {\n    // Optimization: Loop is faster than reduce and allows early exit\n    let current: unknown = obj;\n    const len = path.length;\n\n    for (let i = 0; i < len; i++) {\n        // Optimization: Early return if current value is null/undefined or not an object\n        // This avoids unnecessary key lookups and type checks\n        if (current == null || typeof current !== 'object') {\n            return undefined;\n        }\n\n        const key = path[i];\n\n        if (key !== undefined && key in (current as Record<string | number, unknown>)) {\n            current = (current as Record<string | number, unknown>)[key];\n        }\n        else {\n            return undefined;\n        }\n    }\n\n    return current;\n}\n\n/**\n *\n */\nfunction setNestedValueHelper<T>(obj: T, path: (string | number)[], value: unknown, index: number): T {\n    if (index >= path.length)\n        return obj;\n\n    const head = path[index];\n\n    if (index === path.length - 1) {\n        return {\n            ...(obj as Record<string | number, unknown>),\n            [head as string | number]: value,\n        } as T;\n    }\n\n    const current = (obj as Record<string | number, unknown>)[head as string | number];\n\n    return {\n        ...(obj as Record<string | number, unknown>),\n        [head as string | number | symbol]: setNestedValueHelper(\n            typeof current === 'object' && current !== null\n                ? (current as object)\n                : {},\n            path,\n            value,\n            index + 1,\n        ),\n    } as T;\n}\n\n/**\n * Sets a nested value in an object using a path array.\n * This function creates the path if it doesn't exist and sets the value at the specified location.\n * The function returns a new object with the updated value, maintaining immutability.\n *\n * @param obj - The object to set the value in.\n * @param path - An array of keys representing the path to the desired location.\n * @param value - The value to set at the specified path.\n * @returns A new object with the updated value at the specified path.\n */\nexport function setNestedValue<T>(obj: T, path: (string | number)[], value: unknown): T {\n    if (path.length === 0)\n        return obj;\n\n    return setNestedValueHelper(obj, path, value, 0);\n}\n\n/**\n * Deep clones an object or array.\n * This function creates a deep copy of the input, recursively cloning objects and arrays.\n * Primitive values, dates, and other non-plain objects are returned as is (or cloned if supported).\n * Note: This implementation focuses on plain objects and arrays. For complex types like Map/Set/Buffer/ObjectId,\n * it returns the reference or handles them according to specific logic.\n *\n * @param obj - The object to clone.\n * @returns A deep copy of the object.\n */\nexport function deepClone<T>(obj: T): T {\n    if (obj === null || typeof obj !== 'object') {\n        return obj;\n    }\n\n    if (Array.isArray(obj)) {\n        return obj.map(item => deepClone(item)) as unknown as T;\n    }\n\n    if (obj instanceof Date) {\n        return new Date(obj.getTime()) as unknown as T;\n    }\n\n    if (obj instanceof RegExp) {\n        return new RegExp(obj.source, obj.flags) as unknown as T;\n    }\n\n    // Handle Mongoose ObjectId and other custom classes by returning reference\n    // structuredClone would fail here. We assume if it's not a plain object, we keep the reference\n    // unless we want to implement specific cloning logic for every type.\n    // However, we want to clone POJOs (Plain Old JavaScript Objects).\n    const proto = Object.getPrototypeOf(obj);\n    if (proto !== Object.prototype && proto !== null) {\n        return obj;\n    }\n\n    const result = {} as Record<string, unknown>;\n    for (const key in obj) {\n        if (Object.hasOwn(obj, key)) {\n            result[key] = deepClone((obj as Record<string, unknown>)[key]);\n        }\n    }\n\n    return result as T;\n}\n\n/**\n * Deep merges multiple objects into a single object.\n * @param args - The objects to merge. Can be empty, in which case returns an empty object.\n * @returns The merged object.\n */\nexport function deepMerge<T = Record<string, unknown>>(\n    ...args: (object | null | undefined)[]\n): T;\n\n/**\n * Deep merges multiple arrays into a single array.\n * @param args - The arrays to merge. Can be empty, in which case returns an empty array.\n * @returns The merged array.\n */\nexport function deepMerge<T = unknown[]>(\n    ...args: (unknown[] | null | undefined)[]\n): T;\n\n/**\n * Implementation of deepMerge function.\n * @param args - The objects or arrays to merge.\n * @returns The merged result.\n */\nexport function deepMerge<T = Record<string, unknown> | unknown[]>(\n    ...args: (object | unknown[] | null | undefined)[]\n): T {\n    // Handle empty arguments\n    if (args.length === 0) {\n        return {} as T;\n    }\n\n    // Filter out null/undefined and convert to empty objects/arrays\n    const validArgs = args.filter((arg): arg is object => arg !== null && arg !== undefined);\n\n    // If no valid arguments after filtering, return empty object/array\n    if (validArgs.length === 0) {\n        return {} as T;\n    }\n\n    // If only one argument, return it directly\n    if (validArgs.length === 1) {\n        return validArgs[0] as T;\n    }\n\n    // Check if all arguments are arrays\n    if (validArgs.every(Array.isArray)) {\n        return (validArgs as unknown[][]).flat() as T;\n    }\n\n    // Check if all arguments are objects (but not arrays)\n    if (validArgs.every(arg => typeof arg === 'object' && arg !== null && !Array.isArray(arg))) {\n        const result = {} as Record<string, unknown>;\n\n        for (const arg of validArgs) {\n            const obj = arg as Record<string, unknown>;\n            for (const key in obj) {\n                if (Object.hasOwn(obj, key)) {\n                    const value = obj[key];\n                    if (Object.hasOwn(result, key)) {\n                        const existingValue = result[key];\n                        if (\n                            typeof value === 'object' && value !== null\n                            && typeof existingValue === 'object' && existingValue !== null\n                        ) {\n                            if (Array.isArray(value) && Array.isArray(existingValue)) {\n                                result[key] = [...existingValue, ...value];\n                            }\n                            else if (!Array.isArray(value) && !Array.isArray(existingValue)) {\n                                result[key] = deepMerge(\n                                    existingValue as Record<string, unknown>,\n                                    value as Record<string, unknown>,\n                                );\n                            }\n                            else {\n                                // One is array, other is object (shouldn't happen with strict types but possible)\n                                // Overwrite\n                                result[key] = value;\n                            }\n                        }\n                        else {\n                            result[key] = value;\n                        }\n                    }\n                    else {\n                        result[key] = value;\n                    }\n                }\n            }\n        }\n        return result as T;\n    }\n\n    // Check if all arguments are primitive values\n    if (validArgs.every(arg => typeof arg !== 'object' || arg === null)) {\n        throw new Error(\n            'deepMerge: Cannot merge primitive values. All arguments must be objects or arrays.',\n        );\n    }\n\n    // Mixed types error\n    const hasArrays = validArgs.some(Array.isArray);\n    const hasObjects = validArgs.some(arg =>\n        typeof arg === 'object' && arg !== null && !Array.isArray(arg),\n    );\n\n    if (hasArrays && hasObjects) {\n        throw new Error(\n            'deepMerge: Cannot mix arrays and objects. All arguments must be either arrays or objects.',\n        );\n    }\n\n    // Fallback for unexpected cases\n    throw new Error(\n        'deepMerge: Invalid arguments provided. All arguments must be objects or arrays of the same type.',\n    );\n}\n\n/**\n * Normalizes MongoDB filters to support both dot notation strings and nested objects.\n * This function converts nested object filters to dot notation format while preserving\n * MongoDB operators to ensure consistent behavior across different filter input formats.\n *\n * @param filter - The filter object to normalize.\n * @returns A normalized filter object with nested objects converted to dot notation,\n *          while preserving MongoDB operators as nested objects.\n *\n * @example\n * ```typescript\n * // Both of these will work the same way:\n * normalizeMongoFilter({ \"location.countryId\": \"240\" })\n * normalizeMongoFilter({ location: { countryId: \"240\" } })\n * // Both return: { \"location.countryId\": \"240\" }\n *\n * // MongoDB operators are preserved:\n * normalizeMongoFilter({ id: { $in: [\"240\", \"59\"] } })\n * // Returns: { id: { $in: [\"240\", \"59\"] } }\n * ```\n */\nexport function normalizeMongoFilter<T extends Record<string, unknown>>(filter: T): T {\n    if (!filter || typeof filter !== 'object') {\n        return filter;\n    }\n\n    const normalized: Record<string, unknown> = {};\n\n    /**\n     *\n     */\n    function flatten(current: Record<string, unknown>, prefix: string) {\n        for (const key in current) {\n            if (!Object.hasOwn(current, key))\n                continue;\n\n            const value = current[key];\n            const newKey = prefix ? `${prefix}.${key}` : key;\n\n            if (value && typeof value === 'object' && !Array.isArray(value)) {\n                // Check for Mongo operator\n                let hasMongoOperator = false;\n                for (const subKey in value as Record<string, unknown>) {\n                    if (Object.hasOwn(value, subKey) && subKey.startsWith('$')) {\n                        hasMongoOperator = true;\n                        break;\n                    }\n                }\n\n                if (hasMongoOperator) {\n                    normalized[newKey] = value;\n                }\n                else {\n                    flatten(value as Record<string, unknown>, newKey);\n                }\n            }\n            else {\n                normalized[newKey] = value;\n            }\n        }\n    }\n\n    flatten(filter, '');\n\n    return normalized as T;\n}\n"],"names":["isJSON","str","getNestedValue","obj","path","current","len","i","key","setNestedValueHelper","value","index","head","setNestedValue","deepClone","item","proto","result","deepMerge","args","validArgs","arg","existingValue","hasArrays","hasObjects","normalizeMongoFilter","filter","normalized","flatten","prefix","newKey","hasMongoOperator","subKey"],"mappings":"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"}
+{"version":3,"file":"object.util.js","names":[],"sources":["../../../src/util/object/object.util.ts"],"sourcesContent":["/**\n * Check if a string is a valid JSON string.\n * This function attempts to parse the string as JSON and returns true if successful,\n * false if the string is not valid JSON.\n *\n * @param str - The string to check for valid JSON format.\n * @returns True if the string is a valid JSON string, false otherwise.\n */\nexport function isJSON(str: string): boolean {\n    try {\n        JSON.parse(str);\n        return true;\n    }\n    catch {\n        return false;\n    }\n}\n\n/**\n * Gets a nested value from an object using a path array.\n * This function traverses the object following the provided path and returns\n * the value at the specified location, or undefined if the path doesn't exist.\n *\n * @param obj - The object to get the value from.\n * @param path - An array of keys representing the path to the desired value.\n * @returns The value at the specified path, or undefined if the path doesn't exist.\n */\nexport function getNestedValue<T>(obj: T, path: (string | number)[]): unknown {\n    // Optimization: Loop is faster than reduce and allows early exit\n    let current: unknown = obj;\n    const len = path.length;\n\n    for (let i = 0; i < len; i++) {\n        // Optimization: Early return if current value is null/undefined or not an object\n        // This avoids unnecessary key lookups and type checks\n        if (current == null || typeof current !== 'object') {\n            return undefined;\n        }\n\n        const key = path[i];\n\n        if (key !== undefined && key in (current as Record<string | number, unknown>)) {\n            current = (current as Record<string | number, unknown>)[key];\n        }\n        else {\n            return undefined;\n        }\n    }\n\n    return current;\n}\n\n/**\n * Recursively sets a value at a nested path within an object, creating intermediate objects as needed.\n *\n * @param obj - The source object.\n * @param path - Array of keys forming the path.\n * @param value - The value to set.\n * @param index - Current recursion depth.\n * @returns A new object with the value set at the specified path.\n */\nfunction setNestedValueHelper<T>(obj: T, path: (string | number)[], value: unknown, index: number): T {\n    if (index >= path.length)\n        return obj;\n\n    const head = path[index];\n\n    if (index === path.length - 1) {\n        return {\n            ...(obj as Record<string | number, unknown>),\n            [head as string | number]: value,\n        } as T;\n    }\n\n    const current = (obj as Record<string | number, unknown>)[head as string | number];\n\n    return {\n        ...(obj as Record<string | number, unknown>),\n        [head as string | number | symbol]: setNestedValueHelper(\n            typeof current === 'object' && current !== null\n                ? (current as object)\n                : {},\n            path,\n            value,\n            index + 1,\n        ),\n    } as T;\n}\n\n/**\n * Sets a nested value in an object using a path array.\n * This function creates the path if it doesn't exist and sets the value at the specified location.\n * The function returns a new object with the updated value, maintaining immutability.\n *\n * @param obj - The object to set the value in.\n * @param path - An array of keys representing the path to the desired location.\n * @param value - The value to set at the specified path.\n * @returns A new object with the updated value at the specified path.\n */\nexport function setNestedValue<T>(obj: T, path: (string | number)[], value: unknown): T {\n    if (path.length === 0)\n        return obj;\n\n    return setNestedValueHelper(obj, path, value, 0);\n}\n\n/**\n * Deep clones an object or array.\n * This function creates a deep copy of the input, recursively cloning objects and arrays.\n * Primitive values, dates, and other non-plain objects are returned as is (or cloned if supported).\n * Note: This implementation focuses on plain objects and arrays. For complex types like Map/Set/Buffer/ObjectId,\n * it returns the reference or handles them according to specific logic.\n *\n * @param obj - The object to clone.\n * @returns A deep copy of the object.\n */\nexport function deepClone<T>(obj: T): T {\n    if (obj === null || typeof obj !== 'object') {\n        return obj;\n    }\n\n    if (obj instanceof Date) {\n        return new Date(obj.getTime()) as unknown as T;\n    }\n\n    if (obj instanceof RegExp) {\n        return new RegExp(obj.source, obj.flags) as unknown as T;\n    }\n\n    if (Array.isArray(obj)) {\n        // Optimization: `new Array(len)` + `for` loop is ~10-15% faster than `Array.map` or `Array.from`\n        // for large arrays since it avoids callback overhead and pre-allocates memory.\n        const len = obj.length;\n        // eslint-disable-next-line unicorn/no-new-array -- Pre-allocating array size for performance\n        const arr = new Array(len);\n        for (let i = 0; i < len; i++) {\n            arr[i] = deepClone(obj[i]);\n        }\n        return arr as unknown as T;\n    }\n\n    // Handle Mongoose ObjectId and other custom classes by returning reference.\n    // structuredClone is not used here because it silently corrupts nested non-POJO\n    // types (e.g., ObjectId → plain object) and Date instances in jsdom environments.\n    const proto = Object.getPrototypeOf(obj);\n    if (proto !== Object.prototype && proto !== null) {\n        return obj;\n    }\n\n    const result = {} as Record<string, unknown>;\n    for (const key in obj) {\n        if (Object.hasOwn(obj, key)) {\n            result[key] = deepClone((obj as Record<string, unknown>)[key]);\n        }\n    }\n\n    return result as T;\n}\n\n/**\n * Deep merges multiple objects into a single object.\n * @param args - The objects to merge. Can be empty, in which case returns an empty object.\n * @returns The merged object.\n */\nexport function deepMerge<T = Record<string, unknown>>(\n    ...args: (object | null | undefined)[]\n): T;\n\n/**\n * Deep merges multiple arrays into a single array.\n * @param args - The arrays to merge. Can be empty, in which case returns an empty array.\n * @returns The merged array.\n */\nexport function deepMerge<T = unknown[]>(\n    ...args: (unknown[] | null | undefined)[]\n): T;\n\n/**\n * Implementation of deepMerge function.\n * @param args - The objects or arrays to merge.\n * @returns The merged result.\n */\nexport function deepMerge<T = Record<string, unknown> | unknown[]>(\n    ...args: (object | unknown[] | null | undefined)[]\n): T {\n    // Handle empty arguments\n    if (args.length === 0) {\n        return {} as T;\n    }\n\n    // Filter out null/undefined and convert to empty objects/arrays\n    const validArgs = args.filter((arg): arg is object => arg !== null && arg !== undefined);\n\n    // If no valid arguments after filtering, return empty object/array\n    if (validArgs.length === 0) {\n        return {} as T;\n    }\n\n    // If only one argument, return it directly\n    if (validArgs.length === 1) {\n        return validArgs[0] as T;\n    }\n\n    // Check if all arguments are arrays\n    if (validArgs.every(Array.isArray)) {\n        return (validArgs as unknown[][]).flat() as T;\n    }\n\n    // Check if all arguments are objects (but not arrays)\n    if (validArgs.every(arg => typeof arg === 'object' && arg !== null && !Array.isArray(arg))) {\n        const result = {} as Record<string, unknown>;\n\n        for (const arg of validArgs) {\n            const obj = arg as Record<string, unknown>;\n            for (const key in obj) {\n                if (Object.hasOwn(obj, key)) {\n                    const value = obj[key];\n                    if (Object.hasOwn(result, key)) {\n                        const existingValue = result[key];\n                        if (\n                            typeof value === 'object' && value !== null\n                            && typeof existingValue === 'object' && existingValue !== null\n                        ) {\n                            if (Array.isArray(value) && Array.isArray(existingValue)) {\n                                result[key] = [...existingValue, ...value];\n                            }\n                            else if (!Array.isArray(value) && !Array.isArray(existingValue)) {\n                                result[key] = deepMerge(\n                                    existingValue as Record<string, unknown>,\n                                    value as Record<string, unknown>,\n                                );\n                            }\n                            else {\n                                // One is array, other is object (shouldn't happen with strict types but possible)\n                                // Overwrite\n                                result[key] = value;\n                            }\n                        }\n                        else {\n                            result[key] = value;\n                        }\n                    }\n                    else {\n                        result[key] = value;\n                    }\n                }\n            }\n        }\n        return result as T;\n    }\n\n    // Check if all arguments are primitive values\n    if (validArgs.every(arg => typeof arg !== 'object' || arg === null)) {\n        throw new Error(\n            'deepMerge: Cannot merge primitive values. All arguments must be objects or arrays.',\n        );\n    }\n\n    // Mixed types error\n    const hasArrays = validArgs.some(Array.isArray);\n    const hasObjects = validArgs.some(arg =>\n        typeof arg === 'object' && arg !== null && !Array.isArray(arg),\n    );\n\n    if (hasArrays && hasObjects) {\n        throw new Error(\n            'deepMerge: Cannot mix arrays and objects. All arguments must be either arrays or objects.',\n        );\n    }\n\n    // Fallback for unexpected cases\n    throw new Error(\n        'deepMerge: Invalid arguments provided. All arguments must be objects or arrays of the same type.',\n    );\n}\n\n/**\n * Normalizes MongoDB filters to support both dot notation strings and nested objects.\n * This function converts nested object filters to dot notation format while preserving\n * MongoDB operators to ensure consistent behavior across different filter input formats.\n *\n * @param filter - The filter object to normalize.\n * @returns A normalized filter object with nested objects converted to dot notation,\n *          while preserving MongoDB operators as nested objects.\n *\n * @example\n * ```typescript\n * // Both of these will work the same way:\n * normalizeMongoFilter({ \"location.countryId\": \"240\" })\n * normalizeMongoFilter({ location: { countryId: \"240\" } })\n * // Both return: { \"location.countryId\": \"240\" }\n *\n * // MongoDB operators are preserved:\n * normalizeMongoFilter({ id: { $in: [\"240\", \"59\"] } })\n * // Returns: { id: { $in: [\"240\", \"59\"] } }\n * ```\n */\nexport function normalizeMongoFilter<T extends Record<string, unknown>>(filter: T): T {\n    if (!filter || typeof filter !== 'object') {\n        return filter;\n    }\n\n    const normalized: Record<string, unknown> = {};\n\n    /**\n     * Recursively flattens nested objects into dot-notation keys, preserving MongoDB operators.\n     */\n    function flatten(current: Record<string, unknown>, prefix: string) {\n        for (const key in current) {\n            if (!Object.hasOwn(current, key))\n                continue;\n\n            const value = current[key];\n            const newKey = prefix ? `${prefix}.${key}` : key;\n\n            if (value && typeof value === 'object' && !Array.isArray(value)) {\n                // Skip flattening for Mongoose ObjectId, Date, RegExp, and other non-POJO types\n                const valueProto = Object.getPrototypeOf(value);\n                if (valueProto !== Object.prototype && valueProto !== null) {\n                    normalized[newKey] = value;\n                    continue;\n                }\n\n                // Check for Mongo operator\n                let hasMongoOperator = false;\n                for (const subKey in value as Record<string, unknown>) {\n                    if (Object.hasOwn(value, subKey) && subKey.startsWith('$')) {\n                        hasMongoOperator = true;\n                        break;\n                    }\n                }\n\n                if (hasMongoOperator) {\n                    normalized[newKey] = value;\n                }\n                else {\n                    flatten(value as Record<string, unknown>, newKey);\n                }\n            }\n            else {\n                normalized[newKey] = value;\n            }\n        }\n    }\n\n    flatten(filter, '');\n\n    return normalized as T;\n}\n"],"mappings":"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"}

package/dist/util/serializer/index.js

@@ -1,5 +1,2 @@
-import { serializer as i } from "./serializer.util.js";
-export {
-  i as serializer
-};
-//# sourceMappingURL=index.js.map
+import { serializer as e } from "./serializer.util.js";
+export { e as serializer };