dateConfig.ts

/**
 * @license
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://github.com/IDuxFE/idux/blob/main/LICENSE
 */

import { type InjectionKey, inject } from 'vue'

import { isNil, isString } from 'lodash-es'

import {
  addDays,
  addMonths,
  addQuarters,
  addWeeks,
  addYears,
  endOfDay,
  endOfHour,
  endOfMinute,
  endOfMonth,
  endOfQuarter,
  endOfSecond,
  endOfWeek,
  endOfYear,
  format as formatDate,
  getDate,
  getDay,
  getHours,
  getMilliseconds,
  getMinutes,
  getMonth,
  getQuarter,
  getSeconds,
  getWeek,
  getYear,
  isSameDay,
  isSameHour,
  isSameMinute,
  isSameMonth,
  isSameQuarter,
  isSameSecond,
  isSameWeek,
  isSameYear,
  isValid,
  parse as parseDate,
  setDate,
  setDay,
  setHours,
  setMilliseconds,
  setMinutes,
  setMonth,
  setQuarter,
  setSeconds,
  setWeek,
  setYear,
  startOfDay,
  startOfHour,
  startOfMinute,
  startOfMonth,
  startOfQuarter,
  startOfSecond,
  startOfWeek,
  startOfYear,
  toDate,
} from 'date-fns'

import { useGlobalConfig } from './globalConfig'

export type TimeConfigType = 'hour' | 'minute' | 'second' | 'millisecond'
export type DateConfigType = 'year' | 'quarter' | 'month' | 'week' | 'date' | 'day'

export type DateConfig<P = number | Date, R = Date> = {
  now: () => R
  weekStartsOn: () => number

  get: (date: P, type: DateConfigType | TimeConfigType) => number
  set: (date: P, amount: number, type: DateConfigType | TimeConfigType) => R
  add: (date: P, amount: number, type: DateConfigType) => R
  startOf: (date: P, type: DateConfigType | TimeConfigType) => R
  endOf: (date: P, type: DateConfigType | TimeConfigType) => R
  isSame: (date: P, dateToCompare: P, type: DateConfigType | TimeConfigType) => boolean
  isValid: (date: unknown) => boolean

  format: (date: P, format: string) => string
  parse: (dateString: string, format: string, referenceDate?: Date | number) => R
  convert: (date: unknown, format: string) => R

  getLocalizedLabels: (
    type: 'month' | 'day' | 'dayPeriod',
    maxIndex: number,
    width: 'narrow' | 'abbreviated' | 'wide',
  ) => string[]
}

export const DATE_CONFIG_TOKEN: InjectionKey<DateConfig> = Symbol('DATE_CONFIG_TOKEN')

let defaultDateConfig: DateConfig<number | Date, Date> | undefined

export function useDateConfig(): DateConfig<number | Date, Date> {
  const config = inject(DATE_CONFIG_TOKEN, null)
  if (config) {
    return config
  }
  if (!defaultDateConfig) {
    defaultDateConfig = createDefaultDateConfig()
  }
  return defaultDateConfig
}

function createDefaultDateConfig(): DateConfig<number | Date, Date> {
  const locale = useGlobalConfig('locale')
  const now = () => new Date()
  const parse = (dateString: string, format: string, referenceDate?: Date | number) =>
    parseDate(dateString, format, referenceDate ?? now(), { locale: locale.date })
  return {
    now,
    weekStartsOn: () => locale.date.options?.weekStartsOn ?? 1,
    get: (date, type) => {
      switch (type) {
        case 'year':
          return getYear(date)
        case 'quarter':
          return getQuarter(date)
        case 'month':
          return getMonth(date)
        case 'week':
          return getWeek(date, { locale: locale.date })
        case 'date':
          return getDate(date)
        case 'day':
          return getDay(date)
        case 'hour':
          return getHours(date)
        case 'minute':
          return getMinutes(date)
        case 'second':
          return getSeconds(date)
        case 'millisecond':
          return getMilliseconds(date)
      }
    },
    set: (date, amount, type) => {
      switch (type) {
        case 'year':
          return setYear(date, amount)
        case 'quarter':
          return setQuarter(date, amount)
        case 'month':
          return setMonth(date, amount)
        case 'week':
          return setWeek(date, amount, { locale: locale.date })
        case 'date':
          return setDate(date, amount)
        case 'day':
          return setDay(date, amount, { locale: locale.date })
        case 'hour':
          return setHours(date, amount)
        case 'minute':
          return setMinutes(date, amount)
        case 'second':
          return setSeconds(date, amount)
        case 'millisecond':
          return setMilliseconds(date, amount)
      }
    },
    add: (date, amount, type) => {
      switch (type) {
        case 'year':
          return addYears(date, amount)
        case 'quarter':
          return addQuarters(date, amount)
        case 'month':
          return addMonths(date, amount)
        case 'week':
          return addWeeks(date, amount)
        case 'date':
        case 'day':
          return addDays(date, amount)
      }
    },
    startOf: (date, type) => {
      switch (type) {
        case 'year':
          return startOfYear(date)
        case 'quarter':
          return startOfQuarter(date)
        case 'month':
          return startOfMonth(date)
        case 'week':
          return startOfWeek(date, { locale: locale.date })
        case 'date':
        case 'day':
          return startOfDay(date)
        case 'hour':
          return startOfHour(date)
        case 'minute':
          return startOfMinute(date)
        case 'second':
        case 'millisecond':
          return startOfSecond(date)
      }
    },
    endOf: (date, type) => {
      switch (type) {
        case 'year':
          return endOfYear(date)
        case 'quarter':
          return endOfQuarter(date)
        case 'month':
          return endOfMonth(date)
        case 'week':
          return endOfWeek(date, { locale: locale.date })
        case 'date':
        case 'day':
          return endOfDay(date)
        case 'hour':
          return endOfHour(date)
        case 'minute':
          return endOfMinute(date)
        case 'second':
        case 'millisecond':
          return endOfSecond(date)
      }
    },

    isSame: (date, dateToCompare, type) => {
      switch (type) {
        case 'year':
          return isSameYear(date, dateToCompare)
        case 'quarter':
          return isSameQuarter(date, dateToCompare)
        case 'month':
          return isSameMonth(date, dateToCompare)
        case 'week':
          return isSameWeek(date, dateToCompare, { locale: locale.date })
        case 'date':
        case 'day':
          return isSameDay(date, dateToCompare)
        case 'hour':
          return isSameHour(date, dateToCompare)
        case 'minute':
          return isSameMinute(date, dateToCompare)
        case 'second':
          return isSameSecond(date, dateToCompare)
        case 'millisecond':
          return toDate(date).getTime() === toDate(dateToCompare).getTime()
      }
    },
    isValid: date => isValid(date),

    format: (date, format) => formatDate(date, format, { locale: locale.date }),
    parse: parse,
    convert: (date, format) => {
      if (isNil(date)) {
        return now()
      }
      return isString(date) ? parse(date, format!) : toDate(date as number | Date)
    },
    getLocalizedLabels: (type, length, width) => {
      const localize = locale.date.localize!
      switch (type) {
        case 'month':
          return Array.from({ length }).map((_, i) => localize.month(i, { width }))
        case 'day':
          return Array.from({ length }).map((_, i) => localize!.day(i, { width }))
        case 'dayPeriod':
          return Array.from({ length }).map((_, i) => localize!.dayPeriod(i, { width }))
      }
    },
  }
}