eslink-ui-plus/components/utils/timeOperater.ts

vue3 component library, css framework

interface TimeItem {
	label: string | number
	value: string
}
export const addZero = numb => {
	if (numb < 10) {
		return `0${numb}`
	}
	return numb
}
// 1 3 5 7 8 10 12 : 31d
// 4 6 9  11 : 30d
// 2: 28d
export const getDayListByMonth = (year, month, withUnits: boolean = true) => {
	const dayList: TimeItem[] = []
	const monthDaysMap = {
		31: [1, 3, 5, 7, 8, 10, 12],
		30: [4, 6, 9, 11],
		28: [2],
	}
	const monthDayIndex = Object.values(monthDaysMap).findIndex(monthList =>
		monthList.includes(month),
	)
	const days = Object.keys(monthDaysMap)
	const maxDay = days[monthDayIndex]
	let count = 1
	while (count <= +maxDay) {
		const label = withUnits
			? `${year}-${addZero(month)}-${addZero(count)}`
			: `${addZero(count)}日`
		dayList.push({
			label,
			value: `${year}-${addZero(month)}-${addZero(count)}`,
		})
		count++
	}
	return dayList
	// return {
	// 	label:
	// }
}
export const getWeek = val => {
	const date = val ? new Date(val) : new Date()
	const y = date.getFullYear()
	const M = date.getMonth() + 1
	const d = date.getDate()
	const weekDay = date.getDay()
	const dTimeStamp = +new Date(`${y}-${addZero(M)}-${addZero(d)}`)
	const oneDay = 3600 * 1000 * 24
	let _start, _end
	if (weekDay === 1) {
		_start = dTimeStamp
		_end = _start + 6 * oneDay
	} else if (weekDay > 0) {
		_start = dTimeStamp - (weekDay - 1) * oneDay
		_end = _start + 6 * oneDay
	} else {
		_start = dTimeStamp - (7 - 1) * oneDay
		_end = _start + 6 * oneDay
	}
	const startTimeString = new Date(_start)
		.toLocaleDateString()
		.split('/')
		.map(val => addZero(val))
		.join('-')
	const endTimeString = new Date(_end)
		.toLocaleDateString()
		.split('/')
		.map(val => addZero(val))
		.join('-')
	return {
		timeString: {
			startTime: startTimeString,
			endTime: endTimeString,
		},
		timeStamp: {
			startTime: +new Date(_start),
			endTime: +new Date(_end),
		},
	}
}
export const getMonth = val => {
	const date = val ? new Date(val) : new Date()
	const y = date.getFullYear()
	const M = date.getMonth() + 1
	const oneMonthDays = new Date(y, M, 0).getDate()
	return {
		timeString: {
			startTime: `${y}-${addZero(M)}-01`,
			endTime: `${y}-${addZero(M)}-${oneMonthDays}`,
		},
		timeStamp: {
			startTime: +new Date(`${y}-${addZero(M)}-01`),
			endTime: +new Date(`${y}-${addZero(M)}-${oneMonthDays}`),
		},
	}
}
export const getYear = val => {
	const date = val ? new Date(val) : new Date()
	const y = date.getFullYear()
	return {
		timeString: {
			startTime: `${y}-01-01`,
			endTime: `${y}-12-31`,
		},
		timeStamp: {
			startTime: +new Date(`${y}-01-01`),
			endTime: +new Date(`${y}-12-31`),
		},
	}
}
export const getHalfYear = val => {
	const date = val ? new Date(val) : new Date()
	const y = date.getFullYear()
	const M = date.getMonth() + 1
	const startM = M > 6 ? 7 : 1
	const endM = M > 6 ? 12 : 6
	const endD = M > 6 ? 31 : 30
	return {
		timeString: {
			startTime: `${y}-${addZero(startM)}-01`,
			endTime: `${y}-${addZero(endM)}-${endD}`,
		},
		timeStamp: {
			startTime: +new Date(`${y}-${addZero(startM)}-01`),
			endTime: +new Date(`${y}-${addZero(endM)}-${endD}`),
		},
	}
}
export const getQuarter = val => {
	const date = val ? new Date(val) : new Date()
	const y = date.getFullYear()
	const M = date.getMonth() + 1
	let quarter: null | number = null
	const quarterMap = [
		[1, 2, 3],
		[4, 5, 6],
		[7, 8, 9],
		[10, 11, 12],
	]
	quarterMap.forEach((q, i) => {
		if (q.includes(M)) {
			quarter = i + 1
		}
	})
	const range = _getQuarterRange(quarter)
	return {
		timeString: {
			startTime: `${y}-${range[0]}`,
			endTime: `${y}-${range[1]}`,
		},
		timeStamp: {
			startTime: +new Date(`${y}-${range[0]}`),
			endTime: +new Date(`${y}-${range[1]}`),
		},
	}
}
const _getQuarterRange = quarter => {
	const monthMap = {
		1: ['01-01', '03-31'],
		2: ['04-01', '06-30'],
		3: ['07-01', '09-30'],
		4: ['10-01', '12-31'],
	}
	return monthMap[quarter]
}
export const getYearList = (offset: number = 5) => {
	const yearList: number[] = []
	const currentYear = new Date().getFullYear()
	if (offset === undefined) {
		return []
	}
	offset--
	while (offset) {
		yearList.push(currentYear - offset)
		offset--
	}
	yearList.push(currentYear)
	return yearList
}
interface MonthItem extends TimeItem {
	month: number
}
export const getMonthList = (
	year = new Date().getFullYear(),
	withUnits: boolean = true,
) => {
	const monthList: MonthItem[] = []
	let month = 1
	while (month <= 12) {
		const label = withUnits ? `${month}月` : month
		const monthValue = getMonth(`${year}-${month}-01`).timeString
		monthList.push({
			label,
			value: `${monthValue.startTime}~${monthValue.endTime}`,
			month,
		})
		month++
	}
	return monthList
}
export const getQuarterList = (
	year = new Date().getFullYear(),
	withUnits: boolean = true,
) => {
	const quarterList: TimeItem[] = []
	let quarter = 1
	const quarterStartMap = {
		1: `${year}-01-01`,
		2: `${year}-04-01`,
		3: `${year}-07-01`,
		4: `${year}-10-01`,
	}
	while (quarter <= 4) {
		const label = withUnits ? `第${quarter}季度` : quarter
		const quarterValue = getQuarter(quarterStartMap[quarter]).timeString
		quarterList.push({
			label,
			value: `${quarterValue.startTime}~${quarterValue.endTime}`,
		})
		quarter++
	}
	return quarterList
}

export const getWeekList = (
	year: number = new Date().getFullYear(),
	withUnits: boolean = true,
) => {
	const oneDay = 3600 * 1000 * 24
	const weekList: TimeItem[] = []
	const start = new Date(`${year}-01-01`)
	const stopDay = +new Date(`${year}-12-31`)
	let week = getWeek(start)
	let count = 1
	while (week.timeStamp.startTime <= stopDay) {
		const label = withUnits
			? `第${count}周 (${week.timeString.startTime} ~ ${week.timeString.endTime})`
			: `第${count}周`
		weekList.push({
			label,
			value: `${week.timeString.startTime}~${week.timeString.endTime}`,
		})
		count++
		week = getWeek(week.timeStamp.endTime + oneDay)
	}
	return weekList
}
export const getYearWeekList = (offset: number = 5) => {
	const yearList = getYearList(offset)
	return yearList.map(year => {
		return {
			label: `${year}年`,
			value: `${year}年`,
			children: getWeekList(year).map(week => {
				return {
					complateLabel: `${year}年 ${week.label}`,
					label: week.label,
					value: week.value,
				}
			}),
		}
	})
}
export const getYearMonthList = (offset: number = 5) => {
	const yearList = getYearList(offset)
	return yearList.map(year => {
		return {
			label: `${year}年`,
			value: `${year}年`,
			children: getMonthList(year).map(month => {
				return {
					complateLabel: `${year}年 ${month.label}`,
					label: month.label,
					value: month.value,
				}
			}),
		}
	})
}
export const getYearQuarterList = (offset: number = 5) => {
	const yearList = getYearList(offset)
	return yearList.map(year => {
		return {
			label: `${year}年`,
			value: `${year}年`,
			children: getQuarterList(year).map(quarter => {
				return {
					complateLabel: `${year}年 ${quarter.label}`,
					label: quarter.label,
					value: quarter.value,
				}
			}),
		}
	})
}
export const getYearDayList = (offset: number = 5) => {
	const yearList = getYearList(offset)
	return yearList.map(year => {
		return {
			label: `${year}年`,
			value: `${year}年`,
			children: getMonthList(year).map(month => {
				return {
					label: month.label,
					value: month.value,
					children: getDayListByMonth(year, month.month, false).map(
						day => {
							return {
								complateLabel: `${year}年 ${month.label} ${day.label}`,
								label: day.label,
								value: day.value,
							}
						},
					),
				}
			}),
		}
	})
}
export const getYearLabelList = (offset: number = 5) => {
	const yearList = getYearList(offset)
	return yearList.map(year => {
		const yearValue = getYear(`${year}-01-01`).timeString
		return {
			complateLabel: `${year}年`,
			label: `${year}年`,
			value: `${yearValue.startTime}~${yearValue.endTime}`,
		}
	})
}
export const getYearCanlandar = year => {
	const result: {
		title: string
		list: { week: number; label: string | number; value: string }[]
	}[] = []
	let month = 1
	const weekDescMap = {
		0: '日',
		1: '一',
		2: '二',
		3: '三',
		4: '四',
		5: '五',
		6: '六',
	}

	while (month <= 12) {
		const monthDay = getDayListByMonth(year, month)
		result.push({
			title: `${year}-${addZero(month)}`,
			list: monthDay.map(item => {
				const valueDate = new Date(item.value)
				const week = valueDate.getDay()
				const day = new Date(item.value).getDate()
				return {
					...item,
					week,
					weekDesc: weekDescMap[week],
					day,
				}
			}),
		})
		month++
	}
	return result
}
export default {
	getWeek,
	getMonth,
	getQuarter,
	getHalfYear,
	getYear,
	getMonthList,
	getWeekList,
	getYearDayList,
	getYearWeekList,
	getYearMonthList,
	getYearQuarterList,
	getYearLabelList,
	getYearList,
	getYearCanlandar,
}