[LG-5532] feat(time-input): Segment state utils

packages/date-utils/src/index.ts

@@ -21,6 +21,7 @@ export { isOnOrAfter } from './isOnOrAfter';
 export { isOnOrBefore } from './isOnOrBefore';
 export { isSameTZDay } from './isSameTZDay';
 export { isSameTZMonth } from './isSameTZMonth';
+export { isSameUTCDateTime } from './isSameUTCDateTime';
 export { isSameUTCDay } from './isSameUTCDay';
 export { isSameUTCMonth } from './isSameUTCMonth';
 export { isSameUTCRange } from './isSameUTCRange';

packages/date-utils/src/isSameUTCDateTime/index.ts

@@ -0,0 +1 @@
+export { isSameUTCDateTime } from './isSameUTCDateTime';

packages/date-utils/src/isSameUTCDateTime/isSameUTCDateTime.spec.ts

@@ -0,0 +1,41 @@
+import { isSameUTCDateTime } from './isSameUTCDateTime';
+
+describe('packages/time-input/utils/isSameUTCDateTime', () => {
+  test('returns true if the two dates are the same day and time in UTC', () => {
+    const date1 = new Date('2025-01-01T12:00:00Z');
+    const date2 = new Date('2025-01-01T12:00:00Z');
+    expect(isSameUTCDateTime(date1, date2)).toBe(true);
+  });
+
+  test('returns false if the two dates are not the same day in UTC', () => {
+    const date1 = new Date('2025-01-01T12:00:00Z');
+    const date2 = new Date('2025-01-02T12:00:00Z');
+    expect(isSameUTCDateTime(date1, date2)).toBe(false);
+  });
+
+  test('returns false if the two dates are not the same time in UTC', () => {
+    const date1 = new Date('2025-01-01T12:00:00Z');
+    const date2 = new Date('2025-01-01T12:00:01Z');
+    expect(isSameUTCDateTime(date1, date2)).toBe(false);
+  });
+
+  test('returns false if the two dates are not the same date and time in UTC', () => {
+    const date1 = new Date('2025-02-01T12:00:00Z');
+    const date2 = new Date('2025-01-01T12:00:01Z');
+    expect(isSameUTCDateTime(date1, date2)).toBe(false);
+  });
+
+  test('returns false when one or both dates is null', () => {
+    expect(isSameUTCDateTime(new Date(), null)).toBe(false);
+    expect(isSameUTCDateTime(null, new Date())).toBe(false);
+    expect(isSameUTCDateTime(null, null)).toBe(false);
+  });
+
+  test('returns false when one or both dates is invalid', () => {
+    expect(isSameUTCDateTime(new Date(), new Date('invalid'))).toBe(false);
+    expect(isSameUTCDateTime(new Date('invalid'), new Date())).toBe(false);
+    expect(isSameUTCDateTime(new Date('invalid'), new Date('invalid'))).toBe(
+      false,
+    );
+  });
+});

packages/date-utils/src/isSameUTCDateTime/isSameUTCDateTime.ts

@@ -0,0 +1,25 @@
+import { isValidDate } from '../isValidDate';
+import { DateType } from '../types';
+
+/**
+ * Checks if two dates are the same date and time in UTC.
+ *
+ * @param day1 - The first date to check
+ * @param day2 - The second date to check
+ * @returns Whether the two dates are the same date and time in UTC
+ */
+export const isSameUTCDateTime = (
+  day1?: DateType,
+  day2?: DateType,
+): boolean => {
+  if (!isValidDate(day1) || !isValidDate(day2)) return false;
+
+  return (
+    day1.getUTCDate() === day2.getUTCDate() &&
+    day1.getUTCMonth() === day2.getUTCMonth() &&
+    day1.getUTCFullYear() === day2.getUTCFullYear() &&
+    day1.getUTCHours() === day2.getUTCHours() &&
+    day1.getUTCMinutes() === day2.getUTCMinutes() &&
+    day1.getUTCSeconds() === day2.getUTCSeconds()
+  );
+};

packages/date-utils/src/isSameUTCDay/isSameUTCDay.spec.ts

@@ -4,57 +4,109 @@ import { mockTimeZone } from '../testing/mockTimeZone';
 
 import { isSameUTCDay } from '.';
 
-const TZOffset = -5;
+const americaNewYorkTimeZone = 'America/New_York';
 
 describe('packages/date-utils/isSameUTCDay', () => {
   beforeEach(() => {
-    mockTimeZone('America/New_York', -5);
+    mockTimeZone(americaNewYorkTimeZone, -4); // EDT is UTC-4 (4 hours behind UTC) in September
   });
   afterEach(() => {
     jest.resetAllMocks();
   });
 
   describe('when both dates are defined in UTC', () => {
-    test('returns true', () => {
+    test('returns true when both dates are equal', () => {
       const utc1 = newUTC(2023, 8, 1, 0, 0, 0);
       const utc2 = newUTC(2023, 8, 1, 21, 0, 0);
       expect(isSameUTCDay(utc1, utc2)).toBe(true);
     });
 
-    test('returns false', () => {
+    test('returns false when both dates are not equal', () => {
       const utc1 = newUTC(2023, 8, 1, 0, 0, 0);
       const utc2 = newUTC(2023, 8, 2, 0, 0, 0);
       expect(isSameUTCDay(utc1, utc2)).toBe(false);
     });
   });
 
   describe('when one date is defined locally', () => {
-    test('returns true ', () => {
-      const utc = newUTC(2023, 8, 10, 0, 0, 0);
-      // '2023-09-09T21:00:00' NY time
-      const local = newTZDate(TZOffset, 2023, 8, 9, 21, 0); //2023-09-10 02:00:00 UTC
+    test('returns true when both dates are the same day in UTC', () => {
+      const utc = newUTC(2023, 8, 10, 0, 0, 0); // September 10, 2023 00:00 UTC
+
+      // September 9, 2023 21:00 EDT => September 10, 2023 01:00 UTC
+      const local = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: 8,
+        date: 9,
+        hours: 21,
+        minutes: 0,
+      });
 
       expect(isSameUTCDay(utc, local)).toBe(true);
     });
 
-    test('returns false', () => {
-      const utc = newUTC(2023, 8, 10);
-      // '2023-09-09T12:00' NY time
-      const local = newTZDate(TZOffset, 2023, 8, 9, 12, 0); //2023-09-09 17:00:00 UTC
+    test('returns false when both dates are not the same day in UTC', () => {
+      const utc = newUTC(2023, 8, 10); // September 10, 2023 00:00 UTC
+
+      // September 9, 2023 12:00 EDT => September 9, 2023 16:00 UTC
+      const local = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: 8,
+        date: 9,
+        hours: 12,
+        minutes: 0,
+      });
+
       expect(isSameUTCDay(utc, local)).toBe(false);
     });
   });
 
   describe('when both dates are defined locally', () => {
-    test('returns true', () => {
-      const local1 = newTZDate(TZOffset, 2023, 8, 8, 20, 0); // 02:00 UTC + 1day
-      const local2 = newTZDate(TZOffset, 2023, 8, 9, 18, 0); // 23:00 UTC
+    test('returns true when both dates are the same day in UTC', () => {
+      // September 8, 2023 20:00 EDT => September 9, 2023 00:00 UTC
+      const local1 = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: 8,
+        date: 8,
+        hours: 20,
+        minutes: 0,
+      });
+
+      // September 9, 2023 18:00 EDT => September 9, 2023 22:00 UTC
+      const local2 = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: 8,
+        date: 9,
+        hours: 18,
+        minutes: 0,
+      });
       expect(isSameUTCDay(local1, local2)).toBe(true);
     });
 
-    test('returns false', () => {
-      const local1 = newTZDate(TZOffset, 2023, 8, 9, 0, 0); // 05:00 UTC
-      const local2 = newTZDate(TZOffset, 2023, 8, 9, 20, 0); // 02:00 UTC +1 day
+    test('returns false when both dates are not the same day in UTC', () => {
+      // September 9, 2023 00:00 EDT => September 9, 2023 04:00 UTC
+      const local1 = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: 8,
+        date: 9,
+        hours: 0,
+        minutes: 0,
+      });
+
+      // September 9, 2023 20:00 EDT => September 10, 2023 00:00 UTC
+      const local2 = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: 8,
+        date: 9,
+        hours: 20,
+        minutes: 0,
+      });
+
       expect(isSameUTCDay(local1, local2)).toBe(false);
     });
   });

packages/date-utils/src/isSameUTCMonth/isSameUTCMonth.spec.ts

@@ -5,65 +5,111 @@ import { mockTimeZone } from '../testing/mockTimeZone';
 
 import { isSameUTCMonth } from '.';
 
-const TZOffset = -5;
+const TZOffset = -4;
+const americaNewYorkTimeZone = 'America/New_York';
 
 describe('packages/date-utils/isSameUTCMonth', () => {
   beforeEach(() => {
-    mockTimeZone('America/New_York', TZOffset);
+    mockTimeZone(americaNewYorkTimeZone, TZOffset);
   });
   afterEach(() => {
     jest.resetAllMocks();
   });
 
   describe('when both dates are defined in UTC', () => {
-    test('true', () => {
+    test('returns true when both dates are the same month', () => {
       const utc1 = newUTC(2023, Month.September, 1);
       const utc2 = newUTC(2023, Month.September, 10);
       expect(isSameUTCMonth(utc1, utc2)).toBe(true);
     });
 
-    test('false', () => {
+    test('returns false when both dates are not the same month', () => {
       const utc1 = newUTC(2023, Month.September, 1);
       const utc2 = newUTC(2023, Month.August, 31);
       expect(isSameUTCMonth(utc1, utc2)).toBe(false);
     });
   });
 
   describe('when one date is defined locally', () => {
-    test('true', () => {
+    test('returns true when both dates are the same month in UTC', () => {
       const utc = newUTC(2023, Month.September, 10);
-      const local = newTZDate(TZOffset, 2023, Month.August, 31, 21, 0, 0);
+
+      // August 31, 2023 21:00 EDT (UTC-4) => September 01, 2023 01:00 UTC
+      const local = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: Month.August,
+        date: 31,
+        hours: 21,
+        minutes: 0,
+      });
       expect(isSameUTCMonth(utc, local)).toBe(true);
     });
 
-    test('false', () => {
+    test('returns false when both dates are not the same month in UTC', () => {
       const utc = newUTC(2023, Month.September, 10);
-      const local = newTZDate(TZOffset, 2023, Month.August, 31, 12, 0);
+      // August 31, 2023 12:00 EDT (UTC-4) => August 31, 2023 16:00 UTC
+      const local = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: Month.August,
+        date: 31,
+        hours: 12,
+        minutes: 0,
+      });
       expect(isSameUTCMonth(utc, local)).toBe(false);
     });
   });
 
   describe(' when both dates are defined locally', () => {
-    test('true', () => {
-      const local1 = newTZDate(TZOffset, 2023, Month.September, 1, 0, 0);
-      const local2 = newTZDate(TZOffset, 2023, Month.September, 30, 18, 0);
+    test('returns true when both dates are the same month in UTC', () => {
+      const local1 = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: Month.September,
+        date: 1,
+        hours: 0,
+        minutes: 0,
+      });
+      const local2 = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: Month.September,
+        date: 30,
+        hours: 18,
+        minutes: 0,
+      });
       expect(isSameUTCMonth(local1, local2)).toBe(true);
     });
 
-    test('false', () => {
-      const local1 = newTZDate(TZOffset, 2023, Month.September, 1, 0, 0);
-      const local2 = newTZDate(TZOffset, 2023, Month.September, 30, 20, 0);
+    test('returns false when both dates are not the same month in UTC', () => {
+      const local1 = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: Month.September,
+        date: 1,
+        hours: 0,
+        minutes: 0,
+      });
+      const local2 = newTZDate({
+        timeZone: americaNewYorkTimeZone,
+        year: 2023,
+        month: Month.September,
+        date: 30,
+        hours: 20,
+        minutes: 0,
+      });
       expect(isSameUTCMonth(local1, local2)).toBe(false);
     });
   });
 
-  test('false: when one or both dates is null', () => {
+  test('returns false when one or both dates is null', () => {
     expect(isSameUTCMonth(new Date(), null)).toBe(false);
     expect(isSameUTCMonth(null, new Date())).toBe(false);
     expect(isSameUTCMonth(null, null)).toBe(false);
   });
 
-  test('false for different years', () => {
+  test('returns false for different years', () => {
     const utc1 = newUTC(2023, Month.September, 1);
     const utc2 = newUTC(2024, Month.September, 10);
     expect(isSameUTCMonth(utc1, utc2)).toBe(false);