feat: calendar core

packages/time/src/calendar/splitMultiDayEvents.ts

@@ -16,18 +16,22 @@ export const splitMultiDayEvents = <
   let currentDay = startDate
   while (Temporal.ZonedDateTime.compare(currentDay, endDate) < 0) {
     const eventStart =
-      Temporal.PlainDateTime.compare(currentDay, startDate) === 0
+      Temporal.ZonedDateTime.compare(currentDay, startDate) === 0
         ? startDate
-        : startOf(currentDay, 'day')
+        : startOf({ date: currentDay, unit: 'day' })
     const eventEnd =
-      Temporal.PlainDateTime.compare(endDate, endOf(currentDay, 'day')) < 0
+      Temporal.ZonedDateTime.compare(endDate, endOf({ date: currentDay, unit: 'day' })) < 0
         ? endDate
-        : endOf(currentDay, 'day')
+        : endOf({ date: currentDay, unit: 'day' })
 
-    events.push({ ...event, start: eventStart, end: eventEnd })
+    events.push({
+      ...event,
+      start: eventStart.toString(),
+      end: eventEnd.toString(),
+    })
 
-    currentDay = startOf(currentDay, 'day').add({ days: 1 })
+    currentDay = startOf({ date: currentDay, unit: 'day' }).add({ days: 1 })
   }
 
   return events
-}
+}

packages/time/src/tests/calendar-core.test.ts

@@ -131,10 +131,10 @@ describe('CalendarCore', () => {
             start:
               Temporal.PlainDateTime.from('2024-06-12T11:00').toZonedDateTime(
                 mockTimeZone,
-              ),
+              ).toString(),
             end: Temporal.PlainDateTime.from(
               '2024-06-12T13:00',
-            ).toZonedDateTime(mockTimeZone),
+            ).toZonedDateTime(mockTimeZone).toString(),
           },
         ],
       })
@@ -147,10 +147,10 @@ describe('CalendarCore', () => {
             start:
               Temporal.PlainDateTime.from('2024-06-12T11:00').toZonedDateTime(
                 mockTimeZone,
-              ),
+              ).toString(),
             end: Temporal.PlainDateTime.from(
               '2024-06-12T12:00',
-            ).toZonedDateTime(mockTimeZone),
+            ).toZonedDateTime(mockTimeZone).toString(),
           },
         ],
       })

packages/time/src/tests/endOf.test.ts

@@ -5,43 +5,91 @@ import { endOf } from '../utils'
 describe('endOf', () => {
   test('should get the end of the given day', () => {
     const date = Temporal.ZonedDateTime.from('2023-07-16T12:34:56.789+01:00[Europe/London]')
-    const result = endOf(date, 'day')
-    const expected = Temporal.ZonedDateTime.from('2023-07-16T23:59:59.999+01:00[Europe/London]')
+    const result = endOf({
+      date,
+      unit: 'day',
+    })
+    const expected = Temporal.ZonedDateTime.from('2023-07-16T23:59:59.999999999+01:00[Europe/London]')
     expect(result.equals(expected)).toBe(true)
   })
 
   test('should get the end of the given week', () => {
     const date = Temporal.ZonedDateTime.from('2023-07-13T12:34:56.789+01:00[Europe/London]')
-    const result = endOf(date, 'week')
-    const expected = Temporal.ZonedDateTime.from('2023-07-16T23:59:59.999+01:00[Europe/London]')
+    const result = endOf({
+      date,
+      unit: 'week',
+    })
+    const expected = Temporal.ZonedDateTime.from('2023-07-16T23:59:59.999999999+01:00[Europe/London]')
     expect(result.equals(expected)).toBe(true)
   })
 
   test('should get the end of the given month', () => {
     const date = Temporal.ZonedDateTime.from('2023-07-16T12:34:56.789+01:00[Europe/London]')
-    const result = endOf(date, 'month')
-    const expected = Temporal.ZonedDateTime.from('2023-07-31T23:59:59.999+01:00[Europe/London]')
+    const result = endOf({
+      date,
+      unit: 'month',
+    })
+    const expected = Temporal.ZonedDateTime.from('2023-07-31T23:59:59.999999999+01:00[Europe/London]')
     expect(result.equals(expected)).toBe(true)
   })
 
   test('should get the end of the given year', () => {
     const date = Temporal.ZonedDateTime.from('2023-07-16T12:34:56.789+01:00[Europe/London]')
-    const result = endOf(date, 'year')
-    const expected = Temporal.ZonedDateTime.from('2023-12-31T23:59:59.999+00:00[Europe/London]')
+    const result = endOf({
+      date,
+      unit: 'year',
+    })
+    const expected = Temporal.ZonedDateTime.from('2023-12-31T23:59:59.999999999+00:00[Europe/London]')
     expect(result.equals(expected)).toBe(true)
   })
 
   test('should get the end of the given work week', () => {
     const date = Temporal.ZonedDateTime.from('2023-07-10T12:34:56.789+01:00[Europe/London]')
-    const result = endOf(date, 'workWeek')
-    const expected = Temporal.ZonedDateTime.from('2023-07-14T23:59:59.999+01:00[Europe/London]')
+    const result = endOf({
+      date,
+      unit: 'workWeek',
+    })
+    const expected = Temporal.ZonedDateTime.from('2023-07-14T23:59:59.999999999+01:00[Europe/London]')
     expect(result.equals(expected)).toBe(true)
   })
 
   test('should get the end of the given decade', () => {
     const date = Temporal.ZonedDateTime.from('2023-07-16T12:34:56.789+01:00[Europe/London]')
-    const result = endOf(date, 'decade')
-    const expected = Temporal.ZonedDateTime.from('2029-12-31T23:59:59.999+00:00[Europe/London]')
+    const result = endOf({
+      date,
+      unit: 'decade',
+    })
+    const expected = Temporal.ZonedDateTime.from('2029-12-31T23:59:59.999999999+00:00[Europe/London]')
     expect(result.equals(expected)).toBe(true)
   })
-})
+
+  test('should handle daylight saving time changes', () => {
+    // Test for a date just before the DST change
+    const dateBeforeDST = Temporal.ZonedDateTime.from('2023-10-28T12:00:00+01:00[Europe/London]')
+    const resultBeforeDST = endOf({
+      date: dateBeforeDST,
+      unit: 'day',
+    })
+    const expectedBeforeDST = Temporal.ZonedDateTime.from('2023-10-28T23:59:59.999999999+01:00[Europe/London]')
+    expect(resultBeforeDST.equals(expectedBeforeDST)).toBe(true)
+
+    // Test for a date just after the DST change
+    const dateAfterDST = Temporal.ZonedDateTime.from('2023-10-29T12:00:00+00:00[Europe/London]')
+    const resultAfterDST = endOf({
+      date: dateAfterDST,
+      unit: 'day',
+    })
+    const expectedAfterDST = Temporal.ZonedDateTime.from('2023-10-29T23:59:59.999999999+00:00[Europe/London]')
+    expect(resultAfterDST.equals(expectedAfterDST)).toBe(true)
+  })
+
+  test('should handle different time zones', () => {
+    const dateNY = Temporal.ZonedDateTime.from('2023-07-16T12:34:56.789-04:00[America/New_York]')
+    const resultNY = endOf({
+      date: dateNY,
+      unit: 'day',
+    })
+    const expectedNY = Temporal.ZonedDateTime.from('2023-07-16T23:59:59.999999999-04:00[America/New_York]')
+    expect(resultNY.equals(expectedNY)).toBe(true)
+  })
+})

packages/time/src/utils/endOf.ts

@@ -1,67 +1,68 @@
 import type { Temporal } from '@js-temporal/polyfill'
 
+type ViewUnit = 'month' | 'week' | 'day' | 'workWeek' | 'decade' | 'year'
+
+interface EndOfParams {
+  date: Temporal.ZonedDateTime
+  unit: ViewUnit
+  viewModeValue?: number
+  firstDayOfWeek?: number
+}
+
 /**
  * Helper function to get the end of a given temporal unit.
- * @param date {Temporal.ZonedDateTime} - The date for which the end of the unit is needed.
- * @param unit {Unit} - The unit for which to find the end ('day', 'week', 'month', 'year', 'workWeek', 'decade').
+ * @param {EndOfParams} params - The parameters for the endOf function.
  * @returns {Temporal.ZonedDateTime} The end of the given unit.
  */
-export const endOf = (date: Temporal.ZonedDateTime, unit: 'day' | 'week' | 'month' | 'year' | 'workWeek' | 'decade'): Temporal.ZonedDateTime => {
+export function endOf({
+  date,
+  unit,
+  viewModeValue = 1,
+  firstDayOfWeek = 1,
+}: EndOfParams): Temporal.ZonedDateTime {
+  let endDate: Temporal.ZonedDateTime
+
   switch (unit) {
     case 'day':
-      return date.with({
-        hour: 23,
-        minute: 59,
-        second: 59,
-        millisecond: 999,
-      });
-    case 'week': {
-      const endOfWeek = date.add({ days: 7 - date.dayOfWeek }).with({
-        hour: 23,
-        minute: 59,
-        second: 59,
-        millisecond: 999,
-      });
-      return endOfWeek;
-    }
-    case 'month': {
-      const lastDayOfMonth = date.with({ day: 1 }).add({ months: 1 }).subtract({ days: 1 });
-      return lastDayOfMonth.with({
-        hour: 23,
-        minute: 59,
-        second: 59,
-        millisecond: 999,
-      });
-    }
-    case 'year': {
-      const lastDayOfYear = date.with({ month: 12, day: 31 });
-      return lastDayOfYear.with({
-        hour: 23,
-        minute: 59,
-        second: 59,
-        millisecond: 999,
-      });
-    }
-    case 'workWeek': {
-      const endOfWorkWeek = date.add({ days: 5 - date.dayOfWeek }).with({
-        hour: 23,
-        minute: 59,
-        second: 59,
-        millisecond: 999,
-      });
-      return endOfWorkWeek;
-    }
+      endDate = date
+      break
+    case 'week':
+      endDate = date.add({ days: 7 - date.dayOfWeek })
+      break
+    case 'workWeek':
+      endDate = date.add({ days: 5 - date.dayOfWeek })
+      break
+    case 'month':
+      endDate = date
+        .with({ day: 1 })
+        .add({ months: viewModeValue })
+        .subtract({ days: 1 })
+      if (viewModeValue > 1) {
+        const lastDayOfMonthWeekDay =
+          (endDate.dayOfWeek - firstDayOfWeek + 7) % 7
+        endDate = endDate.add({ days: 6 - lastDayOfMonthWeekDay })
+      }
+      break
+    case 'year':
+      endDate = date.with({ month: 12, day: 31 })
+      break
     case 'decade': {
-      const lastYearOfDecade = date.with({ year: date.year - (date.year % 10) + 9 });
-      const lastDayOfDecade = lastYearOfDecade.with({ month: 12, day: 31 });
-      return lastDayOfDecade.with({
-        hour: 23,
-        minute: 59,
-        second: 59,
-        millisecond: 999,
-      });
+      const lastYearOfDecade = date.with({
+        year: date.year - (date.year % 10) + 9,
+      })
+      endDate = lastYearOfDecade.with({ month: 12, day: 31 })
+      break
     }
     default:
-      throw new Error(`Unsupported unit: ${unit}`);
+      throw new Error(`Unsupported unit: ${unit}`)
   }
+
+  return endDate.with({
+    hour: 23,
+    minute: 59,
+    second: 59,
+    millisecond: 999,
+    microsecond: 999,
+    nanosecond: 999,
+  })
 }