@sabrenski/spire-ui 0.0.1

package/src/utils/date.test.ts

@@ -0,0 +1,522 @@
+import { describe, it, expect } from 'vitest'
+import {
+  generateCalendarGrid,
+  getDaysInMonth,
+  formatDate,
+  parseDate,
+  isSameDate,
+  isDateBefore,
+  isDateAfter,
+  getMonthName,
+  getMonthNamesShort,
+  getWeekdayNames,
+  isDateInRange,
+  isDateBetween,
+  getRangeClass,
+  normalizeRange,
+  generateYearGrid,
+  getPresetRange
+} from './date'
+
+describe('date utilities', () => {
+  describe('generateCalendarGrid', () => {
+    it('returns 42 items (6 rows × 7 columns)', () => {
+      const grid = generateCalendarGrid(2024, 5)
+      expect(grid.length).toBe(42)
+    })
+
+    it('marks current month days correctly', () => {
+      const grid = generateCalendarGrid(2024, 5)
+      const currentMonthDays = grid.filter(d => d.currentMonth)
+      expect(currentMonthDays.length).toBe(30)
+    })
+
+    it('includes padding days from previous month', () => {
+      const grid = generateCalendarGrid(2024, 5)
+      const firstDay = grid[0]
+      expect(firstDay.date.getMonth()).toBe(4)
+    })
+
+    it('includes padding days from next month', () => {
+      const grid = generateCalendarGrid(2024, 5)
+      const lastDay = grid[41]
+      expect(lastDay.date.getMonth()).toBe(6)
+    })
+
+    it('starts week on Sunday', () => {
+      const grid = generateCalendarGrid(2024, 0)
+      expect(grid[0].date.getDay()).toBe(0)
+    })
+
+    it('handles leap year February correctly', () => {
+      const grid = generateCalendarGrid(2024, 1)
+      const febDays = grid.filter(d => d.currentMonth)
+      expect(febDays.length).toBe(29)
+    })
+
+    it('handles non-leap year February correctly', () => {
+      const grid = generateCalendarGrid(2023, 1)
+      const febDays = grid.filter(d => d.currentMonth)
+      expect(febDays.length).toBe(28)
+    })
+  })
+
+  describe('getDaysInMonth', () => {
+    it('returns 31 for January', () => {
+      expect(getDaysInMonth(2024, 0)).toBe(31)
+    })
+
+    it('returns 28 for February in non-leap year', () => {
+      expect(getDaysInMonth(2023, 1)).toBe(28)
+    })
+
+    it('returns 29 for February in leap year', () => {
+      expect(getDaysInMonth(2024, 1)).toBe(29)
+    })
+
+    it('returns 30 for April', () => {
+      expect(getDaysInMonth(2024, 3)).toBe(30)
+    })
+
+    it('handles century years correctly (not leap years)', () => {
+      expect(getDaysInMonth(1900, 1)).toBe(28)
+    })
+
+    it('handles 400-year cycle leap years correctly', () => {
+      expect(getDaysInMonth(2000, 1)).toBe(29)
+    })
+  })
+
+  describe('formatDate', () => {
+    it('formats date to ISO 8601 string', () => {
+      const date = new Date(2024, 5, 15)
+      expect(formatDate(date)).toBe('2024-06-15')
+    })
+
+    it('pads single-digit month with zero', () => {
+      const date = new Date(2024, 0, 15)
+      expect(formatDate(date)).toBe('2024-01-15')
+    })
+
+    it('pads single-digit day with zero', () => {
+      const date = new Date(2024, 5, 5)
+      expect(formatDate(date)).toBe('2024-06-05')
+    })
+
+    it('handles year boundaries', () => {
+      const date = new Date(2024, 11, 31)
+      expect(formatDate(date)).toBe('2024-12-31')
+    })
+  })
+
+  describe('parseDate', () => {
+    it('parses valid ISO date string', () => {
+      const date = parseDate('2024-06-15')
+      expect(date).not.toBeNull()
+      expect(date?.getFullYear()).toBe(2024)
+      expect(date?.getMonth()).toBe(5)
+      expect(date?.getDate()).toBe(15)
+    })
+
+    it('returns null for empty string', () => {
+      expect(parseDate('')).toBeNull()
+    })
+
+    it('returns null for invalid format', () => {
+      expect(parseDate('15-06-2024')).toBeNull()
+      expect(parseDate('2024/06/15')).toBeNull()
+      expect(parseDate('June 15, 2024')).toBeNull()
+    })
+
+    it('returns null for invalid date values', () => {
+      expect(parseDate('2024-13-01')).toBeNull()
+      expect(parseDate('2024-02-30')).toBeNull()
+    })
+
+    it('returns null for partial dates', () => {
+      expect(parseDate('2024-06')).toBeNull()
+      expect(parseDate('2024')).toBeNull()
+    })
+  })
+
+  describe('isSameDate', () => {
+    it('returns true for same dates', () => {
+      const d1 = new Date(2024, 5, 15)
+      const d2 = new Date(2024, 5, 15)
+      expect(isSameDate(d1, d2)).toBe(true)
+    })
+
+    it('returns true for same dates with different times', () => {
+      const d1 = new Date(2024, 5, 15, 10, 30)
+      const d2 = new Date(2024, 5, 15, 18, 45)
+      expect(isSameDate(d1, d2)).toBe(true)
+    })
+
+    it('returns false for different dates', () => {
+      const d1 = new Date(2024, 5, 15)
+      const d2 = new Date(2024, 5, 16)
+      expect(isSameDate(d1, d2)).toBe(false)
+    })
+
+    it('returns false when first date is null', () => {
+      expect(isSameDate(null, new Date())).toBe(false)
+    })
+
+    it('returns false when second date is null', () => {
+      expect(isSameDate(new Date(), null)).toBe(false)
+    })
+
+    it('returns false when both dates are null', () => {
+      expect(isSameDate(null, null)).toBe(false)
+    })
+  })
+
+  describe('isDateBefore', () => {
+    it('returns true when date is before reference', () => {
+      const date = new Date(2024, 5, 14)
+      const reference = new Date(2024, 5, 15)
+      expect(isDateBefore(date, reference)).toBe(true)
+    })
+
+    it('returns false when date is same as reference', () => {
+      const date = new Date(2024, 5, 15)
+      const reference = new Date(2024, 5, 15)
+      expect(isDateBefore(date, reference)).toBe(false)
+    })
+
+    it('returns false when date is after reference', () => {
+      const date = new Date(2024, 5, 16)
+      const reference = new Date(2024, 5, 15)
+      expect(isDateBefore(date, reference)).toBe(false)
+    })
+
+    it('ignores time components', () => {
+      const date = new Date(2024, 5, 14, 23, 59)
+      const reference = new Date(2024, 5, 15, 0, 1)
+      expect(isDateBefore(date, reference)).toBe(true)
+    })
+  })
+
+  describe('isDateAfter', () => {
+    it('returns true when date is after reference', () => {
+      const date = new Date(2024, 5, 16)
+      const reference = new Date(2024, 5, 15)
+      expect(isDateAfter(date, reference)).toBe(true)
+    })
+
+    it('returns false when date is same as reference', () => {
+      const date = new Date(2024, 5, 15)
+      const reference = new Date(2024, 5, 15)
+      expect(isDateAfter(date, reference)).toBe(false)
+    })
+
+    it('returns false when date is before reference', () => {
+      const date = new Date(2024, 5, 14)
+      const reference = new Date(2024, 5, 15)
+      expect(isDateAfter(date, reference)).toBe(false)
+    })
+
+    it('ignores time components', () => {
+      const date = new Date(2024, 5, 16, 0, 1)
+      const reference = new Date(2024, 5, 15, 23, 59)
+      expect(isDateAfter(date, reference)).toBe(true)
+    })
+  })
+
+  describe('getMonthName', () => {
+    it('returns month name for given index', () => {
+      const name = getMonthName(0)
+      expect(name.toLowerCase()).toContain('jan')
+    })
+
+    it('returns correct month for all indices', () => {
+      const months = Array.from({ length: 12 }, (_, i) => getMonthName(i))
+      expect(months.length).toBe(12)
+      expect(new Set(months).size).toBe(12)
+    })
+  })
+
+  describe('getWeekdayNames', () => {
+    it('returns 7 weekday names', () => {
+      const names = getWeekdayNames()
+      expect(names.length).toBe(7)
+    })
+
+    it('starts with Sunday', () => {
+      const names = getWeekdayNames('en-US')
+      expect(names[0].toLowerCase()).toContain('sun')
+    })
+
+    it('all names are unique', () => {
+      const names = getWeekdayNames()
+      expect(new Set(names).size).toBe(7)
+    })
+  })
+
+  describe('isDateInRange', () => {
+    const testDate = new Date(2024, 5, 15)
+    const minDate = new Date(2024, 5, 10)
+    const maxDate = new Date(2024, 5, 20)
+
+    it('returns true when date is within range', () => {
+      expect(isDateInRange(testDate, minDate, maxDate)).toBe(true)
+    })
+
+    it('returns true when date equals min date', () => {
+      expect(isDateInRange(minDate, minDate, maxDate)).toBe(true)
+    })
+
+    it('returns true when date equals max date', () => {
+      expect(isDateInRange(maxDate, minDate, maxDate)).toBe(true)
+    })
+
+    it('returns false when date is before min', () => {
+      const beforeMin = new Date(2024, 5, 5)
+      expect(isDateInRange(beforeMin, minDate, maxDate)).toBe(false)
+    })
+
+    it('returns false when date is after max', () => {
+      const afterMax = new Date(2024, 5, 25)
+      expect(isDateInRange(afterMax, minDate, maxDate)).toBe(false)
+    })
+
+    it('returns true when no constraints', () => {
+      expect(isDateInRange(testDate, null, null)).toBe(true)
+    })
+
+    it('returns true when only min constraint and date is after', () => {
+      expect(isDateInRange(testDate, minDate, null)).toBe(true)
+    })
+
+    it('returns true when only max constraint and date is before', () => {
+      expect(isDateInRange(testDate, null, maxDate)).toBe(true)
+    })
+  })
+
+  describe('isDateBetween', () => {
+    const start = new Date(2024, 5, 10)
+    const end = new Date(2024, 5, 20)
+
+    it('returns true when date is between start and end', () => {
+      const date = new Date(2024, 5, 15)
+      expect(isDateBetween(date, start, end)).toBe(true)
+    })
+
+    it('returns false when date equals start', () => {
+      expect(isDateBetween(start, start, end)).toBe(false)
+    })
+
+    it('returns false when date equals end', () => {
+      expect(isDateBetween(end, start, end)).toBe(false)
+    })
+
+    it('returns false when date is before start', () => {
+      const date = new Date(2024, 5, 5)
+      expect(isDateBetween(date, start, end)).toBe(false)
+    })
+
+    it('returns false when date is after end', () => {
+      const date = new Date(2024, 5, 25)
+      expect(isDateBetween(date, start, end)).toBe(false)
+    })
+
+    it('returns false when start is null', () => {
+      const date = new Date(2024, 5, 15)
+      expect(isDateBetween(date, null, end)).toBe(false)
+    })
+
+    it('returns false when end is null', () => {
+      const date = new Date(2024, 5, 15)
+      expect(isDateBetween(date, start, null)).toBe(false)
+    })
+
+    it('handles reversed range (end before start)', () => {
+      const date = new Date(2024, 5, 15)
+      expect(isDateBetween(date, end, start)).toBe(true)
+    })
+  })
+
+  describe('getRangeClass', () => {
+    const start = new Date(2024, 5, 10)
+    const end = new Date(2024, 5, 20)
+
+    it('returns "start" for range start date', () => {
+      expect(getRangeClass(start, start, end, null)).toBe('start')
+    })
+
+    it('returns "end" for range end date', () => {
+      expect(getRangeClass(end, start, end, null)).toBe('end')
+    })
+
+    it('returns "in-range" for dates between start and end', () => {
+      const middle = new Date(2024, 5, 15)
+      expect(getRangeClass(middle, start, end, null)).toBe('in-range')
+    })
+
+    it('returns null for dates outside range', () => {
+      const outside = new Date(2024, 5, 25)
+      expect(getRangeClass(outside, start, end, null)).toBe(null)
+    })
+
+    it('returns null when start is null', () => {
+      expect(getRangeClass(start, null, end, null)).toBe(null)
+    })
+
+    it('uses hover as effective end when selecting', () => {
+      const hover = new Date(2024, 5, 15)
+      expect(getRangeClass(hover, start, null, hover)).toBe('end')
+    })
+
+    it('returns "start" when only start is selected (no hover)', () => {
+      expect(getRangeClass(start, start, null, null)).toBe('start')
+    })
+
+    it('handles reversed selection (hover before start)', () => {
+      const hover = new Date(2024, 5, 5)
+      expect(getRangeClass(hover, start, null, hover)).toBe('start')
+      expect(getRangeClass(start, start, null, hover)).toBe('end')
+    })
+  })
+
+  describe('normalizeRange', () => {
+    it('returns dates in order when start is before end', () => {
+      const start = new Date(2024, 5, 10)
+      const end = new Date(2024, 5, 20)
+      const [resultStart, resultEnd] = normalizeRange(start, end)
+      expect(resultStart).toBe(start)
+      expect(resultEnd).toBe(end)
+    })
+
+    it('swaps dates when start is after end', () => {
+      const start = new Date(2024, 5, 20)
+      const end = new Date(2024, 5, 10)
+      const [resultStart, resultEnd] = normalizeRange(start, end)
+      expect(resultStart).toBe(end)
+      expect(resultEnd).toBe(start)
+    })
+
+    it('returns same date for both when dates are equal', () => {
+      const date = new Date(2024, 5, 15)
+      const [resultStart, resultEnd] = normalizeRange(date, date)
+      expect(resultStart).toBe(date)
+      expect(resultEnd).toBe(date)
+    })
+  })
+
+  describe('getMonthNamesShort', () => {
+    it('returns 12 month names', () => {
+      const names = getMonthNamesShort()
+      expect(names.length).toBe(12)
+    })
+
+    it('all names are unique', () => {
+      const names = getMonthNamesShort()
+      expect(new Set(names).size).toBe(12)
+    })
+
+    it('returns short month names', () => {
+      const names = getMonthNamesShort('en-US')
+      expect(names[0].length).toBeLessThanOrEqual(4)
+    })
+  })
+
+  describe('generateYearGrid', () => {
+    it('returns 20 years', () => {
+      const years = generateYearGrid(2024)
+      expect(years.length).toBe(20)
+    })
+
+    it('starts from a multiple of 20', () => {
+      const years = generateYearGrid(2024)
+      expect(years[0] % 20).toBe(0)
+    })
+
+    it('contains consecutive years', () => {
+      const years = generateYearGrid(2024)
+      for (let i = 1; i < years.length; i++) {
+        expect(years[i]).toBe(years[i - 1] + 1)
+      }
+    })
+
+    it('contains the center year', () => {
+      const years = generateYearGrid(2024)
+      expect(years).toContain(2024)
+    })
+
+    it('handles different decades', () => {
+      const years2000 = generateYearGrid(2005)
+      expect(years2000[0]).toBe(2000)
+      expect(years2000[years2000.length - 1]).toBe(2019)
+
+      const years2020 = generateYearGrid(2025)
+      expect(years2020[0]).toBe(2020)
+      expect(years2020[years2020.length - 1]).toBe(2039)
+    })
+  })
+
+  describe('getPresetRange', () => {
+    it('returns today for "today" preset', () => {
+      const [start, end] = getPresetRange('today')
+      const today = new Date()
+      expect(start.getDate()).toBe(today.getDate())
+      expect(end.getDate()).toBe(today.getDate())
+    })
+
+    it('returns yesterday for "yesterday" preset', () => {
+      const [start, end] = getPresetRange('yesterday')
+      const yesterday = new Date()
+      yesterday.setDate(yesterday.getDate() - 1)
+      expect(start.getDate()).toBe(yesterday.getDate())
+      expect(end.getDate()).toBe(yesterday.getDate())
+    })
+
+    it('returns 7-day range for "last7days" preset', () => {
+      const [start, end] = getPresetRange('last7days')
+      const diffMs = end.getTime() - start.getTime()
+      const diffDays = Math.round(diffMs / (1000 * 60 * 60 * 24))
+      expect(diffDays).toBe(6)
+    })
+
+    it('returns 30-day range for "last30days" preset', () => {
+      const [start, end] = getPresetRange('last30days')
+      const diffMs = end.getTime() - start.getTime()
+      const diffDays = Math.round(diffMs / (1000 * 60 * 60 * 24))
+      expect(diffDays).toBe(29)
+    })
+
+    it('returns current month for "thisMonth" preset', () => {
+      const [start, end] = getPresetRange('thisMonth')
+      const today = new Date()
+      expect(start.getMonth()).toBe(today.getMonth())
+      expect(end.getMonth()).toBe(today.getMonth())
+      expect(start.getDate()).toBe(1)
+    })
+
+    it('returns previous month for "lastMonth" preset', () => {
+      const [start, end] = getPresetRange('lastMonth')
+      const today = new Date()
+      const lastMonth = today.getMonth() === 0 ? 11 : today.getMonth() - 1
+      expect(start.getMonth()).toBe(lastMonth)
+      expect(end.getMonth()).toBe(lastMonth)
+      expect(start.getDate()).toBe(1)
+    })
+
+    it('returns current year for "thisYear" preset', () => {
+      const [start, end] = getPresetRange('thisYear')
+      const today = new Date()
+      expect(start.getFullYear()).toBe(today.getFullYear())
+      expect(end.getFullYear()).toBe(today.getFullYear())
+      expect(start.getMonth()).toBe(0)
+      expect(start.getDate()).toBe(1)
+      expect(end.getMonth()).toBe(11)
+      expect(end.getDate()).toBe(31)
+    })
+
+    it('returns today for unknown preset', () => {
+      const [start, end] = getPresetRange('unknown')
+      const today = new Date()
+      expect(start.getDate()).toBe(today.getDate())
+      expect(end.getDate()).toBe(today.getDate())
+    })
+  })
+})