utilities.ts

/* eslint-disable @typescript-eslint/no-unsafe-function-type */

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

import {
  type DifferenceType,
  VALUE_CREATED,
  VALUE_DELETED,
  VALUE_UPDATED
} from './types.js'

/**
 * Get the unknown value type as a string
 * @param unknownValue - A value of unknown type
 * @returns The unknown value type as a string
 */
export function getTypeOfUnknown(
  unknownValue: unknown
):
  | 'array'
  | 'boolean'
  | 'date'
  | 'function'
  | 'null'
  | 'number'
  | 'object'
  | 'string'
  | 'symbol'
  | 'undefined' {
  if (unknownValue === null) {
    return 'null'
  } else if (unknownValue === undefined) {
    return 'undefined'
  } else if (typeof unknownValue === 'symbol') {
    return 'symbol'
  } else if (unknownValue instanceof Date) {
    return 'date'
  } else if (Array.isArray(unknownValue)) {
    return 'array'
  } else if (typeof unknownValue === 'function') {
    return 'function'
  }
  return typeof unknownValue as 'boolean' | 'number' | 'object' | 'string'
}

/**
 * Check if the unknown value is blank, which means its either an empty string, undefined or null
 * @param potentialBlank - A value of unknown type
 * @returns True if the value is blank, false otherwise
 */
export function isBlank(potentialBlank: unknown): boolean {
  return (
    potentialBlank === '' ||
    potentialBlank === undefined ||
    potentialBlank === null
  )
}

/**
 * Check if the unknown value is a simple value, which means its either a boolean, number or string
 * @param potentialValue - A value of unknown type
 * @returns True if the value is a simple value, false otherwise
 */
export function isValue(
  potentialValue: unknown
): potentialValue is boolean | number | string {
  return (
    typeof potentialValue === 'boolean' ||
    typeof potentialValue === 'number' ||
    typeof potentialValue === 'string'
  )
}

/**
 * Check if the unknown value is an array
 * @param potentialArray - A value of unknown type
 * @returns True if the value is an array, false otherwise
 */
export function isArray(potentialArray: unknown): potentialArray is unknown[] {
  return !isBlank(potentialArray) && Array.isArray(potentialArray)
}

/**
 * Check if the unknown value is a function
 * @param potentialFunction - A value of unknown type
 * @returns True if the value is a function, false otherwise
 */
export function isFunction(
  potentialFunction: unknown
): potentialFunction is Function {
  return typeof potentialFunction === 'function'
}

/**
 * Check if the unknown value is a symbol
 * @param potentialSymbol - A value of unknown type
 * @returns True if the value is a symbol, false otherwise
 */
export function isSymbol(potentialSymbol: unknown): potentialSymbol is symbol {
  return typeof potentialSymbol === 'symbol'
}

/**
 * Check if the unknown value is an object, which means it's not a simple value, array, date, function or symbol
 * @param potentialObject - A value of unknown type
 * @returns True if the value is an object, false otherwise
 */
export function isObject(potentialObject: unknown): potentialObject is object {
  return (
    !isValue(potentialObject) &&
    !isBlank(potentialObject) &&
    !isDate(potentialObject) &&
    !isArray(potentialObject) &&
    !isFunction(potentialObject) &&
    !isSymbol(potentialObject)
  )
}

export function getDifferenceType(
  valueFrom: unknown,
  valueTo: unknown
): DifferenceType {
  let updateType: DifferenceType = VALUE_UPDATED

  if (isBlank(valueFrom)) {
    updateType = VALUE_CREATED
  } else if (isBlank(valueTo)) {
    updateType = VALUE_DELETED
  }

  return updateType
}