{"version":3,"file":"ObjectUtils.mjs","sources":["../src/ObjectUtils.ts"],"sourcesContent":["/**\n * @module ObjectUtils\n * @description A comprehensive collection of utility functions for object manipulation, transformation, and analysis.\n * @example\n * ```typescript\n * import { ObjectUtils } from 'houser-js-utils';\n *\n * // Deep clone an object\n * const cloned = ObjectUtils.cloneObject(originalObject);\n *\n * // Merge multiple objects\n * const merged = ObjectUtils.merge(obj1, obj2, obj3);\n *\n * // Get nested property safely\n * const value = ObjectUtils.getNestedProp(obj, 'user', 'profile', 'name');\n * ```\n */\n\nexport const ObjectUtils = {\n  /**\n   * Creates a deep clone of an object, including nested objects and arrays.\n   * @template T - The type of the object to clone\n   * @param obj - The object to clone\n   * @returns A deeply cloned copy of the object\n   * @example\n   * ```typescript\n   * const original = { user: { name: 'John', hobbies: ['reading'] } };\n   * const cloned = ObjectUtils.cloneObject(original);\n   * cloned.user.name = 'Jane'; // Original remains unchanged\n   * ```\n   */\n  cloneObject<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) => this.cloneObject(item)) as unknown as T;\n    }\n\n    const clonedObj: Record<string, unknown> = {};\n    for (const key in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, key)) {\n        clonedObj[key] = this.cloneObject(\n          (obj as Record<string, unknown>)[key]\n        );\n      }\n    }\n\n    return clonedObj as T;\n  },\n\n  /**\n   * Performs a deep equality check between two values, comparing all nested properties.\n   * @param obj1 - The first value to compare\n   * @param obj2 - The second value to compare\n   * @returns True if the values are deeply equal, false otherwise\n   * @example\n   * ```typescript\n   * ObjectUtils.deepEqual({ a: { b: 1 } }, { a: { b: 1 } }); // Returns true\n   * ObjectUtils.deepEqual({ a: 1 }, { a: 2 }); // Returns false\n   * ObjectUtils.deepEqual([1, 2, 3], [1, 2, 3]); // Returns true\n   * ```\n   */\n  deepEqual(obj1: unknown, obj2: unknown): boolean {\n    if (obj1 === obj2) {\n      return true;\n    }\n\n    if (\n      typeof obj1 !== \"object\" ||\n      obj1 === null ||\n      typeof obj2 !== \"object\" ||\n      obj2 === null\n    ) {\n      return false;\n    }\n\n    const keys1 = Object.keys(obj1);\n    const keys2 = Object.keys(obj2);\n\n    if (keys1.length !== keys2.length) {\n      return false;\n    }\n\n    return !keys1.some(\n      (key) =>\n        !Object.prototype.hasOwnProperty.call(obj2, key) ||\n        !this.deepEqual((obj1 as any)[key], (obj2 as any)[key])\n    );\n  },\n\n  /**\n   * Filters an array of objects to unique values based on a specified property.\n   * @template T - The type of objects in the array\n   * @param objects - The array of objects to filter\n   * @param prop - The property to use for uniqueness comparison\n   * @returns An array containing only unique objects based on the specified property\n   * @example\n   * ```typescript\n   * const users = [\n   *   { id: 1, name: 'John' },\n   *   { id: 2, name: 'Jane' },\n   *   { id: 1, name: 'John Doe' }\n   * ];\n   * ObjectUtils.filterUniqueByProp(users, 'id'); // Returns first two objects\n   * ```\n   */\n  filterUniqueByProp<T extends Record<string, unknown>>(\n    objects: T[],\n    prop: keyof T\n  ): T[] {\n    if (!objects?.length) return [];\n\n    const flags: Record<string, boolean> = {};\n    return objects.filter((o) => {\n      if (flags[String(o[prop])]) return false;\n      flags[String(o[prop])] = true;\n      return true;\n    });\n  },\n\n  /**\n   * Filters an object to only include the specified keys.\n   * @param obj - The object to filter\n   * @param keys - An array of keys to include in the filtered object\n   * @returns A new object containing only the specified keys\n   * @example\n   * ```typescript\n   * const user = { id: 1, name: 'John', email: 'john@example.com', password: 'secret' };\n   * ObjectUtils.filterByKeys(user, ['id', 'name']); // Returns { id: 1, name: 'John' }\n   * ```\n   */\n  filterByKeys(\n    obj: Record<string, unknown>,\n    keys: string[]\n  ): Record<string, unknown> {\n    return Object.fromEntries(\n      Object.entries(obj).filter(([key]) => keys.includes(key))\n    );\n  },\n\n  /**\n   * Finds the index of the first non-zero value in an object of numbers.\n   * @param data - An object containing numeric values\n   * @returns The index of the first non-zero value, or -1 if all values are zero\n   * @example\n   * ```typescript\n   * ObjectUtils.findFirstNonZeroIndex({ a: 0, b: 0, c: 5, d: 2 }); // Returns 2\n   * ObjectUtils.findFirstNonZeroIndex({ a: 0, b: 0 }); // Returns -1\n   * ```\n   */\n  findFirstNonZeroIndex(data: Record<string, number>): number {\n    return Object.entries(data).findIndex(([_, value]) => value !== 0);\n  },\n\n  /**\n   * Flattens a nested object into a single-level object with dot-notation keys.\n   * @param obj - The object to flatten\n   * @param prefix - The prefix to use for nested keys (default: empty string)\n   * @returns A flattened object with dot-notation keys\n   * @example\n   * ```typescript\n   * const nested = { user: { profile: { name: 'John', age: 30 } } };\n   * ObjectUtils.flatten(nested);\n   * // Returns { 'user.profile.name': 'John', 'user.profile.age': 30 }\n   * ```\n   */\n  flatten(obj: Record<string, unknown>, prefix = \"\"): Record<string, unknown> {\n    return Object.keys(obj).reduce(\n      (acc: Record<string, unknown>, key: string) => {\n        const prefixedKey = prefix ? `${prefix}.${key}` : key;\n        if (\n          typeof obj[key] === \"object\" &&\n          obj[key] !== null &&\n          !Array.isArray(obj[key])\n        ) {\n          Object.assign(\n            acc,\n            this.flatten(obj[key] as Record<string, unknown>, prefixedKey)\n          );\n        } else {\n          acc[prefixedKey] = obj[key];\n        }\n        return acc;\n      },\n      {}\n    );\n  },\n\n  /**\n   * Converts a Map to a plain object\n   * @param map - Map to convert\n   * @returns Plain object\n   */\n  fromMap<T>(map: Map<string, T> | Record<string, T>): Record<string, T> {\n    if (!map) return {};\n    return map instanceof Map ? Object.fromEntries(map) : map;\n  },\n\n  /**\n   * Gets a nested property from an object\n   * @param obj - Object to get property from\n   * @param path - Path to property\n   * @returns Property value or null if not found\n   */\n  getNestedProp<T>(obj: Record<string, unknown>, ...path: string[]): T | null {\n    if (!obj || path.length === 0 || Object.keys(obj).length === 0) {\n      return null;\n    }\n\n    let value: unknown = obj;\n\n    for (const prop of path) {\n      if (\n        !value ||\n        typeof (value as Record<string, unknown>)[prop] === \"undefined\"\n      ) {\n        return null;\n      }\n      value = (value as Record<string, unknown>)[prop];\n    }\n\n    if (this.isObject(value) && Object.keys(value as object).length === 0) {\n      return null;\n    }\n\n    return value as T;\n  },\n\n  /**\n   * Groups objects by a property value\n   * @param objects - Array of objects to group\n   * @param propPath - Path to property to group by\n   * @returns Object with grouped arrays\n   */\n  groupByProp<T extends Record<string, unknown>>(\n    objects: T[],\n    ...propPath: string[]\n  ): Record<string, T[]> {\n    const grouping: Record<string, T[]> = {};\n\n    if (!objects) {\n      return grouping;\n    }\n\n    objects.forEach((obj) => {\n      const val = this.getNestedProp(obj, ...propPath);\n\n      if (typeof val === \"undefined\" || val === null) {\n        return;\n      }\n\n      const key = String(val);\n      if (!grouping[key]) {\n        grouping[key] = [];\n      }\n\n      grouping[key].push(obj);\n    });\n\n    return grouping;\n  },\n\n  /**\n   * Checks if an object has a nested property\n   * @param obj - Object to check\n   * @param path - Path to property\n   * @returns True if property exists\n   */\n  hasNestedProp(obj: Record<string, unknown>, ...path: string[]): boolean {\n    if (!obj || path.length === 0 || Object.keys(obj).length === 0)\n      return false;\n\n    let value: unknown = obj;\n\n    for (const prop of path) {\n      if (\n        !value ||\n        typeof (value as Record<string, unknown>)[prop] === \"undefined\"\n      ) {\n        return false;\n      }\n      value = (value as Record<string, unknown>)[prop];\n    }\n\n    return true;\n  },\n\n  /**\n   * Checks if an object is empty\n   * @param obj - Object to check\n   * @returns True if object is empty\n   */\n  isEmpty(obj: unknown): boolean {\n    return (\n      [Object, Array].includes((obj || {}).constructor as any) &&\n      !Object.entries(obj || {}).length\n    );\n  },\n\n  /**\n   * Checks if a value is a function\n   * @param value - Value to check\n   * @returns True if value is a function\n   */\n  isFunction(value: unknown): value is Function {\n    return value instanceof Function;\n  },\n\n  /**\n   * Checks if two objects are equal using JSON stringification\n   * @param obj1 - First object to compare\n   * @param obj2 - Second object to compare\n   * @returns True if objects are equal\n   */\n  isEqual(obj1: unknown, obj2: unknown): boolean {\n    if (!obj1 || !obj2) return false;\n    return JSON.stringify(obj1) === JSON.stringify(obj2);\n  },\n\n  /**\n   * Compares objects based on specified keys\n   * @param obj1 - First object to compare\n   * @param obj2 - Second object to compare\n   * @param keys - Array of keys to compare\n   * @returns True if objects are equal on specified keys\n   */\n  isEqualOnKeys(\n    obj1: Record<string, unknown>,\n    obj2: Record<string, unknown>,\n    keys: string[]\n  ): boolean {\n    return this.deepEqual(\n      this.filterByKeys(obj1, keys),\n      this.filterByKeys(obj2, keys)\n    );\n  },\n\n  /**\n   * Checks if a value is an object\n   * @param value - Value to check\n   * @returns True if value is an object\n   */\n  isObject(value: unknown): value is Record<string, unknown> {\n    return value !== null && typeof value === \"object\";\n  },\n\n  /**\n   * Maps objects by a property value\n   * @param objects - Array of objects to map\n   * @param propPath - Path to property to map by\n   * @returns Object with mapped values\n   */\n  mapByProp<T extends Record<string, unknown>>(\n    objects: T[],\n    ...propPath: string[]\n  ): Record<string, T> {\n    if (!objects) {\n      return {};\n    }\n\n    const groups = this.groupByProp(objects, ...propPath);\n    const result: Record<string, T> = {};\n\n    Object.keys(groups).forEach((k) => {\n      result[k] = groups[k][0];\n    });\n\n    return result;\n  },\n\n  /**\n   * Checks if an object conforms to a set of rules\n   * @param obj - Object to check\n   * @param ruleSet - Object containing validation functions\n   * @returns True if object conforms to all rules\n   */\n  matchesRules<T extends Record<string, unknown>>(\n    obj: T,\n    ruleSet: Record<keyof T, (value: unknown) => boolean>\n  ): boolean {\n    return Object.keys(ruleSet).every((key) =>\n      ruleSet[key as keyof T](obj[key])\n    );\n  },\n\n  /**\n   * Deep merges two or more objects\n   * @param objects - Objects to merge\n   * @returns Merged object\n   */\n  merge<T extends Record<string, unknown>>(...objects: T[]): T {\n    return objects.reduce((result, current) => {\n      Object.keys(current).forEach((key) => {\n        const typedKey = key as keyof T;\n        if (\n          this.isObject(current[typedKey]) &&\n          this.isObject(result[typedKey])\n        ) {\n          result[typedKey] = this.merge(\n            result[typedKey] as Record<string, unknown>,\n            current[typedKey] as Record<string, unknown>\n          ) as T[keyof T];\n        } else {\n          result[typedKey] = current[typedKey];\n        }\n      });\n      return result;\n    }, {} as T);\n  },\n\n  /**\n   * Creates a new object with specified keys omitted\n   * @param obj - Object to omit keys from\n   * @param keys - Keys to omit\n   * @returns New object without specified keys\n   */\n  omit<T extends Record<string, unknown>>(obj: T, keys: string[]): Partial<T> {\n    const result: Partial<T> = {};\n    Object.keys(obj).forEach((key) => {\n      if (!keys.includes(key)) {\n        result[key as keyof T] = obj[key as keyof T];\n      }\n    });\n    return result;\n  },\n\n  /**\n   * Creates a new object with only the specified keys\n   * @param obj - Object to pick from\n   * @param keys - Keys to pick\n   * @returns New object with only specified keys\n   */\n  pick<T extends Record<string, unknown>>(obj: T, keys: string[]): Partial<T> {\n    return Object.fromEntries(\n      Object.entries(obj).filter(([key]) => keys.includes(key))\n    ) as Partial<T>;\n  },\n\n  /**\n   * Removes null, undefined, and optionally empty string values from an object\n   * @param obj - Object to clean\n   * @param noEmptyStrings - Whether to remove empty strings\n   * @returns Cleaned object\n   */\n  removeNullishValues<T extends Record<string, unknown>>(\n    obj: T,\n    noEmptyStrings = false\n  ): Partial<T> {\n    const result = { ...obj };\n    Object.keys(result).forEach((key) => {\n      if (\n        result[key] === null ||\n        result[key] === undefined ||\n        (noEmptyStrings && result[key] === \"\")\n      ) {\n        delete result[key];\n      }\n    });\n    return result;\n  },\n\n  /**\n   * Replaces empty strings with null in an object\n   * @param obj - Object to process\n   * @param deep - Whether to process nested objects\n   * @returns Processed object\n   */\n  replaceEmptyStringsWithNull(\n    obj: Record<string, unknown>,\n    deep = false\n  ): Record<string, unknown> {\n    return Object.fromEntries(\n      Object.entries(obj).map(([key, value]) => [\n        key,\n        value === \"\"\n          ? null\n          : deep && typeof value === \"object\" && value !== null\n          ? Array.isArray(value)\n            ? value.map((item) =>\n                typeof item === \"object\" && item !== null\n                  ? this.replaceEmptyStringsWithNull(\n                      item as Record<string, unknown>,\n                      deep\n                    )\n                  : item === \"\"\n                  ? null\n                  : item\n              )\n            : this.replaceEmptyStringsWithNull(\n                value as Record<string, unknown>,\n                deep\n              )\n          : value,\n      ])\n    );\n  },\n\n  /**\n   * Replaces a key in an object\n   * @param obj - Object to modify\n   * @param oldKey - Key to replace\n   * @param newKey - New key name\n   * @returns New object with replaced key\n   */\n  replaceKey<T extends Record<string, unknown>>(\n    obj: T,\n    oldKey: keyof T,\n    newKey: string\n  ): Record<string, unknown> {\n    const newObj: Record<string, unknown> = {};\n    for (const key in obj) {\n      if (key === oldKey) {\n        newObj[newKey] = obj[oldKey];\n      } else {\n        newObj[key] = obj[key];\n      }\n    }\n    return newObj;\n  },\n\n  /**\n   * Replaces null values with empty strings in an object\n   * @param obj - Object to process\n   * @param fields - Optional array of fields to process\n   * @returns Processed object\n   */\n  replaceNullWithEmptyString(\n    obj: Record<string, unknown>,\n    fields?: string[]\n  ): Record<string, unknown> {\n    return Object.fromEntries(\n      Object.entries(obj).map(([key, value]) => [\n        key,\n        (!fields && value === null) || (fields?.includes(key) && value === null)\n          ? \"\"\n          : value,\n      ])\n    );\n  },\n\n  /**\n   * Sets a nested property in an object\n   * @param obj - Object to modify\n   * @param path - Path to property\n   * @param value - Value to set\n   * @returns New object with set property\n   */\n  setNestedProp<T extends Record<string, unknown>>(\n    obj: T,\n    ...path: [...string[], unknown]\n  ): T | null {\n    if (!obj) {\n      return null;\n    }\n\n    const value = path.pop();\n    const props = path as string[];\n\n    const localSet = (\n      objParam: Record<string, unknown>,\n      props: string[]\n    ): Record<string, unknown> => {\n      const first = props.shift()!;\n      const newObj = { ...objParam };\n\n      if (props.length === 0) {\n        newObj[first] = value;\n      } else {\n        newObj[first] = localSet(\n          (newObj[first] as Record<string, unknown>) || {},\n          props\n        );\n      }\n\n      return newObj;\n    };\n\n    return localSet(obj, props) as T;\n  },\n\n  /**\n   * Sorts an array of objects by a property\n   * @param objects - Array of objects to sort\n   * @param prop - Property to sort by\n   * @param direction - Sort direction\n   * @returns Sorted array\n   */\n  sortByProp<T extends Record<string, unknown>>({\n    objects,\n    prop,\n    direction = \"asc\",\n  }: {\n    objects: T[];\n    prop: keyof T;\n    direction?: \"asc\" | \"desc\";\n  }): T[] {\n    if (!objects) return [];\n    return [...objects].sort((a, b) => {\n      const aVal = String(a[prop]);\n      const bVal = String(b[prop]);\n      return direction === \"asc\"\n        ? aVal.localeCompare(bVal)\n        : bVal.localeCompare(aVal);\n    });\n  },\n\n  /**\n   * Converts an object to a Map\n   * @param obj - Object to convert\n   * @returns Map\n   */\n  toMap<T>(obj: Record<string, T>): Map<string, T> {\n    if (!obj) return new Map();\n    return new Map(Object.entries(obj));\n  },\n\n  /**\n   * Transforms an object's keys and/or values\n   * @param obj - Object to transform\n   * @param keyTransform - Function to transform keys\n   * @param valueTransform - Function to transform values\n   * @returns Transformed object\n   */\n  transform<T extends Record<string, unknown>>(\n    obj: T,\n    keyTransform?: (key: string) => string,\n    valueTransform?: (value: unknown) => unknown\n  ): Record<string, unknown> {\n    return Object.entries(obj).reduce((acc, [key, value]) => {\n      const newKey = keyTransform ? keyTransform(key) : key;\n      const newValue = valueTransform ? valueTransform(value) : value;\n      acc[newKey] = newValue;\n      return acc;\n    }, {} as Record<string, unknown>);\n  },\n};\n"],"names":["props"],"mappings":"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"}