index.ts

import { isDate } from 'node:util/types'

import { type Difference, NOT_COMPARABLE, VALUE_UPDATED } from './types.js'
import {
  getDifferenceType,
  getTypeOfUnknown,
  isArray,
  isFunction,
  isObject,
  isSymbol,
  isValue
} from './utilities.js'

function _getFullPropertyName(
  parentName: string,
  propertyName: string
): string {
  return parentName ? `${parentName}.${propertyName}` : propertyName
}

function _getArrayDifference(
  parentName: string,
  propertyName: string,
  a1: unknown[],
  a2: unknown[]
): Difference[] {
  const diff: Difference[] = []

  function comparer(otherArray: unknown[]) {
    return function (current: unknown) {
      return (
        otherArray.filter(
          (other) => JSON.stringify(other) === JSON.stringify(current)
        ).length === 0
      )
    }
  }

  const onlyInA1 = a1.filter(comparer(a2))

  const onlyInA2 = a2.filter(comparer(a1))

  for (const [index, element] of onlyInA1.entries()) {
    diff.push(
      ..._getObjectDifference(
        _getFullPropertyName(parentName, propertyName),
        `[${index}]`,
        element,
        undefined
      )
    )
  }

  for (const [index, element] of onlyInA2.entries()) {
    diff.push(
      ..._getObjectDifference(
        _getFullPropertyName(parentName, propertyName),
        `[${index}]`,
        undefined,
        element
      )
    )
  }

  return diff
}

// eslint-disable-next-line @typescript-eslint/max-params
function _getArrayDifferenceByKey(
  parentName: string,
  propertyName: string,
  a1: unknown[],
  a2: unknown[],
  keyProperty: string
): Difference[] {
  const diff: Difference[] = []

  function comparer(otherArray: unknown[]) {
    return function (current: unknown) {
      return (
        otherArray.filter(
          (other) => other[keyProperty] === current[keyProperty]
        ).length === 0
      )
    }
  }

  const onlyInA1 = a1.filter(comparer(a2))

  const onlyInA2 = a2.filter(comparer(a1))

  for (const element of onlyInA1) {
    diff.push(
      ..._getObjectDifference(
        _getFullPropertyName(parentName, propertyName),
        `[${keyProperty}=${element[keyProperty]}]`,
        element,
        undefined
      )
    )
  }

  for (const element of onlyInA2) {
    diff.push(
      ..._getObjectDifference(
        _getFullPropertyName(parentName, propertyName),
        `[${keyProperty}=${element[keyProperty]}]`,
        undefined,
        element
      )
    )
  }

  for (const element of a1) {
    const a2Item = a2.find((x) => x[keyProperty] === element[keyProperty])

    if (a2Item) {
      diff.push(
        ..._getObjectDifference(
          _getFullPropertyName(parentName, propertyName),
          `[${keyProperty}=${element[keyProperty]}]`,
          element,
          a2Item
        )
      )
    }
  }

  return diff
}

// eslint-disable-next-line @typescript-eslint/max-params
function _getObjectDifference(
  parentName: string,
  propertyName: string,
  valueFrom: unknown,
  valueTo: unknown,
  config: { ArrayKeyProperty?: string } = {}
): Difference[] {
  const diff: Difference[] = []

  if (propertyName === '__ob__' || propertyName === '__proto__') {
    return diff
  }

  /*
   * Type check
   */

  const fromType = getTypeOfUnknown(valueFrom)
  const toType = getTypeOfUnknown(valueTo)

  if (fromType !== toType) {
    const differenceType = getDifferenceType(valueFrom, valueTo)

    diff.push({
      property: _getFullPropertyName(parentName, propertyName),
      type: differenceType,
      from: valueFrom,
      to: valueTo
    })

    return diff
  }

  /*
   * Same type check
   */

  if (isValue(valueFrom) && isValue(valueTo)) {
    if (valueFrom === valueTo) {
      return diff
    }

    const differenceType = getDifferenceType(valueFrom, valueTo)

    diff.push({
      property: _getFullPropertyName(parentName, propertyName),
      type: differenceType,
      from: valueFrom,
      to: valueTo
    })

    return diff
  }

  if (isDate(valueFrom) && isDate(valueTo)) {
    if (valueFrom.getTime() === valueTo.getTime()) {
      return diff
    }

    diff.push({
      property: _getFullPropertyName(parentName, propertyName),
      type: VALUE_UPDATED,
      from: valueFrom,
      to: valueTo
    })

    return diff
  }

  if (isFunction(valueFrom) || isFunction(valueTo)) {
    diff.push({
      property: _getFullPropertyName(parentName, propertyName),
      type: NOT_COMPARABLE,
      from: valueFrom,
      to: valueTo
    })

    return diff
  }

  if (isSymbol(valueFrom) || isSymbol(valueTo)) {
    diff.push({
      property: _getFullPropertyName(parentName, propertyName),
      type: VALUE_UPDATED,
      from: valueFrom,
      to: valueTo
    })

    return diff
  }

  if (isArray(valueFrom) && isArray(valueTo)) {
    if (config.ArrayKeyProperty) {
      // check whether Array element has the key
      let missKeyProperty = false

      for (const element of valueFrom) {
        if (element[config.ArrayKeyProperty] === undefined) {
          missKeyProperty = true
        }
      }
      for (const element of valueTo) {
        if (element[config.ArrayKeyProperty] === undefined) {
          missKeyProperty = true
        }
      }

      if (missKeyProperty) {
        diff.push(
          ..._getArrayDifference(parentName, propertyName, valueFrom, valueTo)
        )
      } else {
        diff.push(
          ..._getArrayDifferenceByKey(
            parentName,
            propertyName,
            valueFrom,
            valueTo,
            config.ArrayKeyProperty
          )
        )
      }
    } else {
      diff.push(
        ..._getArrayDifference(parentName, propertyName, valueFrom, valueTo)
      )
    }

    return diff
  }

  if (isObject(valueFrom) && isObject(valueTo)) {
    for (const propertyKey of Object.getOwnPropertyNames(valueFrom)) {
      diff.push(
        ..._getObjectDifference(
          _getFullPropertyName(parentName, propertyName),
          propertyKey,
          valueFrom[propertyKey],
          valueTo[propertyKey]
        )
      )
    }

    for (const propertyKey of Object.getOwnPropertyNames(valueTo)) {
      if (valueFrom[propertyKey] !== undefined) {
        continue
      }

      diff.push(
        ..._getObjectDifference(
          _getFullPropertyName(parentName, propertyName),
          propertyKey,
          undefined,
          valueTo[propertyKey]
        )
      )
    }
  }

  return diff
}

/**
 * Get deep difference between two objects. An empty array will be returned for two same objects comparing.
 * @param valueFrom value comparing on the left
 * @param valueTo value comparing on the right
 * @returns List of differences. An empty array will be returned for two same objects comparing.
 */
export default function getObjectDifference(
  valueFrom: unknown,
  valueTo: unknown
): Difference[] {
  const differences = _getObjectDifference('', '', valueFrom, valueTo)

  return differences
}

export {
  type Difference,
  NOT_COMPARABLE,
  VALUE_CREATED,
  VALUE_DELETED,
  VALUE_UPDATED
} from './types.js'