object.ts

import isEqual from 'lodash/isEqual'

// Using native implementations instead of lodash to reduce bundle size
// isEqual is kept from lodash as it handles deep equality complex cases

type RemoveUndefined<T extends object> = {
  [K in keyof T as T[K] extends undefined ? never : K]: Exclude<T[K], undefined>
}

export const removeUndefinedProps = <T extends object>(
  obj: T,
): RemoveUndefined<T> => {
  const newObj: Record<string, unknown> = {}

  for (const key of Object.keys(obj)) {
    const value = obj[key as keyof T]
    if (value !== undefined) {
      newObj[key] = value
    }
  }

  return newObj as RemoveUndefined<T>
}

export const removeNullOrUndefinedProps = <T extends object>(
  obj: T,
  exceptions?: string[],
): T => {
  const newObj: Record<string, unknown> = {}

  for (const key of Object.keys(obj)) {
    const value = obj[key as keyof T]
    if (
      (value !== undefined && value !== null) ||
      (exceptions ?? []).includes(key)
    ) {
      newObj[key] = value
    }
  }
  return newObj as T
}

export const addObjects = <T extends { [key: string]: number }>(
  obj1: T,
  obj2: T,
): T => {
  // Native implementation replaces lodash union
  const keys = [...new Set([...Object.keys(obj1), ...Object.keys(obj2)])]
  const newObj: { [key: string]: number } = {}

  for (const key of keys) {
    newObj[key] = (obj1[key] ?? 0) + (obj2[key] ?? 0)
  }

  return newObj as T
}

export const subtractObjects = <T extends { [key: string]: number }>(
  obj1: T,
  obj2: T,
): T => {
  // Native implementation replaces lodash union
  const keys = [...new Set([...Object.keys(obj1), ...Object.keys(obj2)])]
  const newObj: { [key: string]: number } = {}

  for (const key of keys) {
    newObj[key] = (obj1[key] ?? 0) - (obj2[key] ?? 0)
  }

  return newObj as T
}

export const hasChanges = <T extends object>(obj: T, partial: Partial<T>) => {
  // Native implementation replaces lodash mapValues
  const currValues = Object.fromEntries(
    Object.keys(partial).map((key) => [key, obj[key as keyof T]])
  )
  return JSON.stringify(currValues) !== JSON.stringify(partial)
}

export const hasSignificantDeepChanges = <T extends object>(
  obj: T,
  partial: Partial<T>,
  epsilonForNumbers: number,
): boolean => {
  const compareValues = (currValue: any, partialValue: any): boolean => {
    if (typeof currValue === 'number' && typeof partialValue === 'number') {
      return Math.abs(currValue - partialValue) > epsilonForNumbers
    }
    if (typeof currValue === 'object' && typeof partialValue === 'object') {
      return hasSignificantDeepChanges(
        currValue,
        partialValue,
        epsilonForNumbers,
      )
    }
    return !isEqual(currValue, partialValue)
  }

  for (const key in partial) {
    if (Object.prototype.hasOwnProperty.call(partial, key)) {
      if (compareValues(obj[key], partial[key])) {
        return true
      }
    }
  }

  return false
}

export const filterObject = <T extends object>(
  obj: T,
  predicate: (value: any, key: keyof T) => boolean,
): { [P in keyof T]: T[P] } => {
  const result = {} as { [P in keyof T]: T[P] }
  for (const key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
      if (predicate(obj[key], key)) {
        result[key] = obj[key]
      }
    }
  }
  return result
}

/**
 * Asserts that a condition is true. If the condition is false, it throws an error with the provided message.
 * @param condition The condition to check
 * @param message The error message to display if the condition is false
 * @throws {Error} If the condition is false
 */
export function assert(condition: boolean, message: string): asserts condition {
  if (!condition) {
    throw new Error(`Assertion failed: ${message}`)
  }
}