@bagelink/vue 1.9.192 → 1.10.1

package/src/utils/calendar/dateUtils.ts

@@ -1,63 +1,9 @@
-import type { DateLike } from '@vueuse/core'
-import type { DateTimeAcceptedFormats, TimeUnit } from '../../types/timeAgoT'
+import type { TimeUnit } from '../../types/timeAgoT'
+import { timeDelta, formatDate, fmtDate, handleTimezone, getDatePartsMap } from '@bagelink/utils'
 import { getI18n } from '../../i18n'
 
-interface TimeDeltaOptions {
-	Day?: number
-	Hour?: number
-	Minute?: number
-	Second?: number
-	Week?: number
-	Month?: number
-	Year?: number
-	days?: number
-	hours?: number
-	minutes?: number
-	seconds?: number
-	weeks?: number
-	months?: number
-	years?: number
-	day?: number
-	hour?: number
-	minute?: number
-	second?: number
-	week?: number
-	month?: number
-	year?: number
-}
-
-export function timeDelta(date: string | Date, options: TimeDeltaOptions) {
-	date = new Date(date)
-	const day = options.Day || options.day || options.days || 0
-	const hour = options.Hour || options.hour || options.hours || 0
-	const minute = options.Minute || options.minute || options.minutes || 0
-	const second = options.Second || options.second || options.seconds || 0
-	const week = options.Week || options.week || options.weeks || 0
-	const month = options.Month || options.month || options.months || 0
-	const year = options.Year || options.year || options.years || 0
-	if (day) {
-		date.setDate(date.getDate() + day)
-	}
-	if (hour) {
-		date.setHours(date.getHours() + hour)
-	}
-	if (minute) {
-		date.setMinutes(date.getMinutes() + minute)
-	}
-	if (second) {
-		date.setSeconds(date.getSeconds() + second)
-	}
-	if (week) {
-		date.setDate(date.getDate() + week * 7)
-	}
-	if (month) {
-		date.setMonth(date.getMonth() + month)
-	}
-	if (year) {
-		date.setFullYear(date.getFullYear() + year)
-	}
-	return date
-}
+export { fmtDate, formatDate, getDatePartsMap, handleTimezone, timeDelta }
+export type { DateTimeAcceptedFormats, FormatDateOptions } from '@bagelink/utils'
 
 type TimeAgoLang = 'en' | 'es' | 'fr' | 'he' | 'it' | 'ru'
 
@@ -74,61 +20,36 @@ interface TimeAgoTranslations {
 	justNow: string
 }
 
-/**
- * Get timeAgo translations from i18n instance
- */
 function getTimeAgoTranslations(lang: TimeAgoLang): TimeAgoTranslations {
+	const fallback: TimeAgoTranslations = {
+		year: 'year',
+		month: 'month',
+		week: 'week',
+		day: 'day',
+		hour: 'hour',
+		minute: 'minute',
+		second: 'second',
+		ago: 'ago',
+		in: 'in',
+		justNow: 'Just now',
+	}
 	try {
 		const i18n = getI18n()
 		const messages = i18n.global.messages as Record<string, { timeAgo?: TimeAgoTranslations }>
 		const localeMessages = messages[lang] || messages.en
-		if (localeMessages?.timeAgo) {
-			return localeMessages.timeAgo
-		}
-		// Fallback to English if timeAgo not found
-		return {
-			year: 'year',
-			month: 'month',
-			week: 'week',
-			day: 'day',
-			hour: 'hour',
-			minute: 'minute',
-			second: 'second',
-			ago: 'ago',
-			in: 'in',
-			justNow: 'Just now',
-		}
+		return localeMessages?.timeAgo ?? fallback
 	} catch {
-		// Fallback if i18n not initialized
-		return {
-			year: 'year',
-			month: 'month',
-			week: 'week',
-			day: 'day',
-			hour: 'hour',
-			minute: 'minute',
-			second: 'second',
-			ago: 'ago',
-			in: 'in',
-			justNow: 'Just now',
-		}
+		return fallback
 	}
 }
 
-/**
- * Get current locale from i18n instance
- */
 function getCurrentLocale(): TimeAgoLang {
 	try {
 		const i18n = getI18n()
 		const { locale } = i18n.global
 		const lang = typeof locale === 'string' ? locale : locale.value
-		// Map to supported timeAgo languages
-		const supportedLangs: TimeAgoLang[] = ['en', 'es', 'fr', 'he', 'it', 'ru']
-		if (supportedLangs.includes(lang as TimeAgoLang)) {
-			return lang as TimeAgoLang
-		}
-		return 'en'
+		const supported: TimeAgoLang[] = ['en', 'es', 'fr', 'he', 'it', 'ru']
+		return supported.includes(lang as TimeAgoLang) ? lang as TimeAgoLang : 'en'
 	} catch {
 		return 'en'
 	}
@@ -138,21 +59,16 @@ export function timeAgo(
 	date: string | Date,
 	langOrConfig?: TimeAgoLang | { lang?: TimeAgoLang, mode?: 'relative' | 'absolute' }
 ) {
-	if (!date) { return '' }
-	if (typeof date === 'string') { date = new Date(date) }
+	if (!date) return ''
+	if (typeof date === 'string') date = new Date(date)
 
-	// Parse config - use global i18n locale if no lang specified
 	const lang = typeof langOrConfig === 'string'
 		? langOrConfig
 		: (langOrConfig?.lang || getCurrentLocale())
 	const mode = typeof langOrConfig === 'object' ? (langOrConfig.mode || 'relative') : 'relative'
 	const isRelative = mode === 'relative'
 
-	const now: Date = new Date()
-	const nowNumber = now.getTime()
-	const dateNumber = date.getTime()
-	const seconds = Math.floor((dateNumber - nowNumber) / 1000)
-
+	const seconds = Math.floor((date.getTime() - Date.now()) / 1000)
 	const intervals = [
 		{ label: 'year', seconds: 31536000 },
 		{ label: 'month', seconds: 2592000 },
@@ -160,293 +76,45 @@ export function timeAgo(
 		{ label: 'day', seconds: 86400 },
 		{ label: 'hour', seconds: 3600 },
 		{ label: 'minute', seconds: 60 },
-		{ label: 'second', seconds: 1 }
+		{ label: 'second', seconds: 1 },
 	]
 
-	const selectedLang = getTimeAgoTranslations(lang)
-
-	// Helper to get time unit translation
-	const getTimeUnit = (label: string): string | TimeUnit => {
-		const key = label as keyof TimeAgoTranslations
-		return selectedLang[key] as string | TimeUnit
-	}
+	const t = getTimeAgoTranslations(lang)
+	const getUnit = (label: string): string | TimeUnit => t[label as keyof TimeAgoTranslations] as string | TimeUnit
 
 	for (const interval of intervals) {
 		const count = Math.floor(Math.abs(seconds) / interval.seconds)
 		if (count >= 1) {
-			const suffix = isRelative && seconds < 0 ? ` ${selectedLang.ago}` : ''
-			const prefix = isRelative && seconds > 0 && selectedLang.in !== 'in' ? `${selectedLang.in} ` : ''
+			const suffix = isRelative && seconds < 0 ? ` ${t.ago}` : ''
+			const prefix = isRelative && seconds > 0 && t.in !== 'in' ? `${t.in} ` : ''
 
-			// Handle Hebrew plural forms
 			if (lang === 'he') {
-				const timeUnit = getTimeUnit(interval.label) as TimeUnit
-				const form = count === 1 ? timeUnit.singular : timeUnit.plural
-
-				// For Hebrew, we place the prefix/suffix before the number
-				const hebrewPrefix = isRelative
-					? (seconds < 0 ? `${selectedLang.ago} ` : (seconds > 0 ? `${selectedLang.in} ` : ''))
+				const unit = getUnit(interval.label) as TimeUnit
+				const form = count === 1 ? unit.singular : unit.plural
+				const hePrefix = isRelative
+					? (seconds < 0 ? `${t.ago} ` : (seconds > 0 ? `${t.in} ` : ''))
 					: ''
 
 				if (interval.label === 'day' && seconds > 0) {
 					const hours = Math.floor((Math.abs(seconds) % 86400) / 3600)
-					const hourUnit = selectedLang.hour as TimeUnit
+					const hourUnit = t.hour as TimeUnit
 					const hourForm = hours === 1 ? hourUnit.singular : hourUnit.plural
-					const mainPart = count === 1 ? form : `${count} ${form}`
-					const hoursPart = hours > 0 ? (hours === 1 ? ` ${hourForm}` : ` ${hours} ${hourForm}`) : ''
-					return `${hebrewPrefix}${mainPart}${hoursPart}`
+					const main = count === 1 ? form : `${count} ${form}`
+					const hourPart = hours > 0 ? (hours === 1 ? ` ${hourForm}` : ` ${hours} ${hourForm}`) : ''
+					return `${hePrefix}${main}${hourPart}`
 				}
-				return `${hebrewPrefix}${count === 1 ? form : `${count} ${form}`}`
+				return `${hePrefix}${count === 1 ? form : `${count} ${form}`}`
 			}
 
-			// Handle other languages
-			const intervalLabel = getTimeUnit(interval.label) as string
+			const label = getUnit(interval.label) as string
 			if (interval.label === 'day' && seconds > 0) {
 				const hours = Math.floor((Math.abs(seconds) % 86400) / 3600)
-				const hourLabel = hours > 1 ? `${selectedLang.hour}s` : selectedLang.hour as string
-				return `${prefix}${count} ${intervalLabel}${hours > 0 ? ` ${hours} ${hourLabel}` : ''}${suffix}`
+				const hourLabel = hours > 1 ? `${t.hour}s` : t.hour as string
+				return `${prefix}${count} ${label}${hours > 0 ? ` ${hours} ${hourLabel}` : ''}${suffix}`
 			}
-			return `${prefix}${count} ${intervalLabel}${suffix}`
+			return `${prefix}${count} ${label}${suffix}`
 		}
 	}
 
-	return selectedLang.justNow as string
-}
-
-function getBrowserNavigatorLocale(): string {
-	if (typeof navigator !== 'object') { return 'en-US' }
-	return navigator.languages && navigator.languages.length
-		? navigator.languages[0]
-		: navigator.language
-}
-
-/**
- * Returns the active i18n locale if initialized, otherwise falls back to
- * the browser's navigator locale. Used as the default for formatDate.
- */
-function getActiveLocale(): string {
-	try {
-		const { locale } = getI18n().global
-		return typeof locale === 'string' ? locale : locale.value
-	} catch {
-		return getBrowserNavigatorLocale()
-	}
-}
-
-/**
- * Adjust a date for a specific timezone
- * @param date The date to adjust
- * @param timeZone The timezone to use (e.g., 'UTC', 'America/New_York')
- * @returns Date parts with timezone adjustment applied
- */
-export function handleTimezone(date: Date, intFmtOpt: Intl.DateTimeFormatOptions): Date {
-	// If timeZone is UTC, convert to UTC directly
-	if (intFmtOpt.timeZone === 'UTC') {
-		const utcDate = new Date(date.getTime())
-		utcDate.setMinutes(utcDate.getMinutes() + date.getTimezoneOffset())
-		return utcDate
-	}
-
-	// For other timezones, use the Intl API
-	try {
-		// Always use en-US locale for parsing date parts to ensure Latin numerals
-		const formatter = new Intl.DateTimeFormat('en-US', {
-			...intFmtOpt,
-			month: 'numeric' // Force numeric month format
-		})
-
-		// Format the date in the target timezone
-		const formattedParts = formatter.formatToParts(date)
-
-		// Extract date components from formatted parts
-		const parts: Record<string, number> = {}
-
-		formattedParts.forEach((part) => {
-			if (part.type !== 'literal' && part.type !== 'timeZoneName') {
-				parts[part.type] = Number.parseInt(part.value, 10)
-			}
-		})
-
-		// Create a new date with these components
-		const adjustedDate = new Date(
-			parts.year,
-			(parts.month || 1) - 1, // Month is 0-based in JS
-			parts.day,
-			parts.hour || 0,
-			parts.minute || 0,
-			parts.second || 0
-		)
-
-		return adjustedDate
-	} catch (error) {
-		console.warn(`Error handling timezone ${intFmtOpt.timeZone}:`, error)
-		return date // Return original date on error
-	}
-}
-
-export function getDatePartsMap(date: Date, locale: Intl.LocalesArgument, intFmtOpt?: Intl.DateTimeFormatOptions) {
-	// Apply timezone adjustment if specified
-	const d = intFmtOpt?.timeZone ? handleTimezone(date, intFmtOpt) : date
-
-	// Use numeric formatting for year to ensure consistency across locales
-	const year = d.getFullYear().toString()
-
-	/// keep-sorted
-	return {
-		AmPm: d.toLocaleString(locale, { hour: 'numeric', hour12: true, minute: 'numeric' }).split(' ')[1],
-		DD: String(d.getDate()).padStart(2, '0'),
-		DDD: d.toLocaleString(locale, { weekday: 'short' }),
-		DDDD: d.toLocaleString(locale, { weekday: 'long' }),
-		HH: String(d.getHours()).padStart(2, '0'),
-		mm: String(d.getMinutes()).padStart(2, '0'),
-		MM: String(d.getMonth() + 1).padStart(2, '0'),
-		MMM: d.toLocaleString(locale, { month: 'short' }),
-		MMMM: d.toLocaleString(locale, { month: 'long' }),
-		ss: String(d.getSeconds()).padStart(2, '0'),
-		sss: String(d.getMilliseconds()).padStart(3, '0'),
-
-		// Always use Latin numerals for year to ensure consistency
-		YY: year.slice(-2),
-		YYYY: year,
-	}
-}
-
-// ? Avoid creating the date parts map on every call
-const _datePartsMapNow = getDatePartsMap(new Date(), getBrowserNavigatorLocale())
-
-// Sort tokens by length (longest first) to avoid partial replacements
-const _orderedDateTokens = (
-	Object.keys(_datePartsMapNow).sort((a, b) => b.length - a.length)
-) as (keyof typeof _datePartsMapNow)[]
-
-// ? Avoid creating the token regex pattern on every call
-// ? no longer creating the Regex Objs it in a loop
-const _tokenRegExPattern = new RegExp(_orderedDateTokens.map(token => token).join('|'), 'g')
-
-export interface FormatDateOptions extends Partial<Pick<Intl.DateTimeFormatOptions, 'hour12'>> {
-	format?: DateTimeAcceptedFormats
-	locale?: Intl.LocalesArgument
-	tz?: string
-}
-
-/**
- * Formats a date based on the provided format string, locale, and timezone.
- * @param date The date to format (string or Date object).
- * @param format The format string (default is 'DD.MM.YY').
- * @returns Formatted date string.
- */
-export function formatDate(date?: DateLike, format?: DateTimeAcceptedFormats): string
-
-/**
- * Formats a date based on the provided options.
- * @param date The date to format (string or Date object).
- * @param opts Options for formatting the date.
- * @param opts.format The format string (default is 'DD.MM.YY').
- * @param opts.locale The locale to use for formatting (default is browser's locale).
- * @param opts.tz The timezone to use for formatting (default is local timezone).
- * @returns Formatted date string.
- */
-export function formatDate(date?: DateLike, opts?: FormatDateOptions): string
-
-/**
- * Formats a date based on the provided format string, locale, and timezone.
- * @param date The date to format (string or Date object).
- * @param formatOrOpts The format string or options object.
- * @returns Formatted date string.
- */
-export function formatDate(
-	date?: DateLike,
-	formatOrOpts?: DateTimeAcceptedFormats | FormatDateOptions,
-): string {
-	let format: DateTimeAcceptedFormats | undefined
-	let locale: Intl.LocalesArgument | undefined
-	let timeZone: string | undefined
-	let rest: Partial<Pick<Intl.DateTimeFormatOptions, 'hour12'>> = {}
-	// Handle both overloads
-	if (typeof formatOrOpts === 'string') {
-		// First overload: format string directly
-		format = formatOrOpts
-	} else if (formatOrOpts && typeof formatOrOpts === 'object') {
-		// Second overload: options object
-		format = formatOrOpts.format
-		locale = formatOrOpts.locale
-		timeZone = formatOrOpts.tz
-		rest = formatOrOpts
-	}
-
-	if (!date) { return '' }
-
-	// Handle named format shortcuts before token replacement
-	if (format === 'ISO' || format === 'ISO8601') {
-		const d = typeof date === 'string' || typeof date === 'number' ? new Date(date) : date
-		return Number.isNaN(d.getTime()) ? '' : d.toISOString()
-	}
-
-	format = format || 'DD.MM.YY'
-
-	locale = locale || getActiveLocale()
-	try {
-		// Validate the date
-		const d = typeof date === 'string' || typeof date === 'number' ? new Date(date) : date
-
-		// Check if date is valid
-		if (Number.isNaN(d.getTime())) {
-			console.warn('Invalid date provided to formatDate:', date)
-			return ''
-		}
-
-		// For more complex formats that need localization, use Intl.DateTimeFormat
-		/// keep-sorted
-		const intFmtOpt: Intl.DateTimeFormatOptions = {
-			day: 'numeric',
-			hour: '2-digit',
-
-			// Set default hour12 to true if not explicitly set
-			// hour12: true,
-			hour12: rest.hour12 === undefined ? true : rest.hour12,
-			minute: '2-digit',
-			month: 'long',
-			second: '2-digit',
-			timeZone, // Add timeZone if provided
-			weekday: 'long',
-			year: 'numeric',
-		}
-
-		const datePartsMap = getDatePartsMap(d, locale, intFmtOpt)
-
-		const formatter = new Intl.DateTimeFormat(locale, intFmtOpt)
-
-		const formattedParts = formatter.formatToParts(d)
-		const partsMap: Partial<Record<Intl.DateTimeFormatPartTypes, string>> = {}
-
-		formattedParts.forEach((part) => {
-			if (part.type !== 'literal') {
-				partsMap[part.type] = part.value
-			}
-		})
-
-		// Add localized formats to our map
-		if (partsMap.month) {
-			datePartsMap.MMM = partsMap.month.substring(0, 3)
-			datePartsMap.MMMM = partsMap.month
-		}
-
-		if (partsMap.weekday) {
-			datePartsMap.DDD = partsMap.weekday.substring(0, 3)
-			datePartsMap.DDDD = partsMap.weekday
-		}
-
-		if (partsMap.dayPeriod) {
-			datePartsMap.AmPm = partsMap.dayPeriod
-		}
-
-		// Process the format string by replacing each token with its value
-		return format.replace(
-			_tokenRegExPattern,
-			match => datePartsMap[match as keyof typeof datePartsMap]
-		)
-	} catch (error) {
-		console.warn(`Error formatting date: ${date} with format: ${format}`, error)
-		return ''
-	}
+	return t.justNow as string
 }
-export const fmtDate = formatDate