@nova-design-system/nova-webcomponents 3.0.0 → 3.2.0

package/dist/collection/components/nv-calendar/test/nv-calendar.utils.test.js

@@ -0,0 +1,667 @@
+import { describe, it, expect, vi } from "vitest";
+import { getWeekNumber, parseDate, isSameDate, isSameOrAfter, isSameOrBefore, formatDate, } from "../nv-calendar.utils";
+describe('nv-calendar -> utils', () => {
+    describe('getWeekNumber', () => {
+        it('should return the correct week number for the first day of the year', () => {
+            const date = new Date(2023, 0, 1); // January 1, 2023
+            expect(getWeekNumber(date)).toBe(1);
+        });
+        it('should return the correct week number for a day in the middle of the year', () => {
+            const date = new Date(2023, 6, 15); // July 15, 2023
+            expect(getWeekNumber(date)).toBe(28);
+        });
+        it('should return the correct week number for the last day of the year', () => {
+            const date = new Date(2023, 11, 31); // December 31, 2023
+            expect(getWeekNumber(date)).toBe(53);
+        });
+        it('should handle leap years correctly', () => {
+            const date = new Date(2024, 1, 29); // February 29, 2024 (leap year)
+            expect(getWeekNumber(date)).toBe(9);
+        });
+        it('should handle years where January 1 is not a Sunday', () => {
+            // January 1, 2022 was a Saturday, which affects week calculations
+            const date = new Date(2022, 0, 1); // January 1, 2022
+            expect(getWeekNumber(date)).toBe(1);
+            const secondWeek = new Date(2022, 0, 9); // January 9, 2022
+            expect(getWeekNumber(secondWeek)).toBe(3);
+        });
+        it('should handle edge cases between years', () => {
+            // Last few days of December and first few days of January
+            const dec31 = new Date(2022, 11, 31); // December 31, 2022
+            const jan1 = new Date(2023, 0, 1); // January 1, 2023
+            expect(getWeekNumber(dec31)).toBe(53);
+            expect(getWeekNumber(jan1)).toBe(1);
+        });
+        it('should return consistent results for the same date in different time zones', () => {
+            const date = new Date(2023, 5, 15);
+            const originalHours = date.getHours();
+            // Simulate different times on the same day
+            date.setHours(0);
+            const earlyResult = getWeekNumber(date);
+            date.setHours(23);
+            const lateResult = getWeekNumber(date);
+            expect(earlyResult).toBe(lateResult);
+            // Reset to avoid affecting other tests
+            date.setHours(originalHours);
+        });
+        it('should handle historic dates correctly', () => {
+            const historicDate = new Date(2000, 0, 1); // January 1, 2000
+            expect(getWeekNumber(historicDate)).toBe(1);
+        });
+    });
+    describe('parseDate', () => {
+        // Date object handling
+        it('should return the original Date when a Date object is passed', () => {
+            const date = new Date(2023, 5, 15); // June 15, 2023
+            const result = parseDate(date, 'YYYY-MM-DD');
+            expect(result).toBe(date); // Check it's the same object reference
+            expect(result === null || result === void 0 ? void 0 : result.getTime()).toBe(date.getTime()); // Double-check timestamp equality
+        });
+        // ISO 8601 format detection
+        it('should automatically detect and parse ISO 8601 format', () => {
+            const isoString = '2023-06-15T12:30:45.123Z';
+            const result = parseDate(isoString, 'any-format');
+            expect(result).toBeInstanceOf(Date);
+            expect(result === null || result === void 0 ? void 0 : result.toISOString()).toBe(isoString);
+        });
+        it('should handle ISO 8601 parsing errors gracefully', () => {
+            // Mock console.error to prevent actual errors in test output
+            const consoleSpy = vi
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            // Invalid ISO string that looks close but is malformed
+            const invalidIsoString = '2023-06-15T25:30:45.123Z'; // 25 hours is invalid
+            const result = parseDate(invalidIsoString, 'YYYY-MM-DD');
+            expect(result).toBeNull();
+            expect(consoleSpy).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+        // Unix timestamp formats
+        it('should parse Unix seconds (X format)', () => {
+            const unixSeconds = '1623760245'; // June 15, 2021, 12:30:45 UTC
+            const result = parseDate(unixSeconds, 'X');
+            expect(result).toBeInstanceOf(Date);
+            expect(result === null || result === void 0 ? void 0 : result.getTime()).toBe(1623760245000);
+        });
+        it('should parse Unix milliseconds (x format)', () => {
+            const unixMilliseconds = '1623760245123'; // June 15, 2021, 12:30:45.123 UTC
+            const result = parseDate(unixMilliseconds, 'x');
+            expect(result).toBeInstanceOf(Date);
+            expect(result === null || result === void 0 ? void 0 : result.getTime()).toBe(1623760245123);
+        });
+        it('should handle invalid Unix timestamps', () => {
+            const consoleSpy = vi
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            // Non-numeric Unix timestamp
+            const invalidUnixSeconds = 'abc';
+            const result = parseDate(invalidUnixSeconds, 'X');
+            expect(result).toBeNull();
+            consoleSpy.mockRestore();
+        });
+        // C# Ticks format
+        it('should parse C# Ticks format', () => {
+            // Test the actual implementation with a known Ticks value
+            // .NET Ticks value (621355968000000000 is the offset for Unix epoch)
+            const csharpTicks = '637593021450000000';
+            const result = parseDate(csharpTicks, 'Ticks');
+            expect(result).toBeInstanceOf(Date);
+            // Instead of comparing to a specific date, let's verify the result is reasonable
+            // by checking basic properties
+            if (result) {
+                expect(result.getFullYear()).toBeGreaterThan(2000); // Should be a date after 2000
+                expect(result.getFullYear()).toBeLessThan(2030); // Should be a date before 2030
+            }
+        });
+        it('should handle invalid Ticks format', () => {
+            const consoleSpy = vi
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            const invalidTicks = 'abc';
+            const result = parseDate(invalidTicks, 'Ticks');
+            expect(result).toBeNull();
+            consoleSpy.mockRestore();
+        });
+        // Common date formats
+        it('should parse YYYY-MM-DD format', () => {
+            const dateStr = '2023-06-15';
+            const result = parseDate(dateStr, 'YYYY-MM-DD');
+            expect(result).toBeInstanceOf(Date);
+            expect(result === null || result === void 0 ? void 0 : result.getFullYear()).toBe(2023);
+            expect(result === null || result === void 0 ? void 0 : result.getMonth()).toBe(5); // 0-based, so June is 5
+            expect(result === null || result === void 0 ? void 0 : result.getDate()).toBe(15);
+        });
+        it('should parse DD-MM-YYYY format', () => {
+            const dateStr = '15-06-2023';
+            const result = parseDate(dateStr, 'DD-MM-YYYY');
+            expect(result).toBeInstanceOf(Date);
+            expect(result === null || result === void 0 ? void 0 : result.getFullYear()).toBe(2023);
+            expect(result === null || result === void 0 ? void 0 : result.getMonth()).toBe(5);
+            expect(result === null || result === void 0 ? void 0 : result.getDate()).toBe(15);
+        });
+        it('should parse MM/DD/YYYY format', () => {
+            const dateStr = '06/15/2023';
+            const result = parseDate(dateStr, 'MM/DD/YYYY');
+            expect(result).toBeInstanceOf(Date);
+            expect(result === null || result === void 0 ? void 0 : result.getFullYear()).toBe(2023);
+            expect(result === null || result === void 0 ? void 0 : result.getMonth()).toBe(5);
+            expect(result === null || result === void 0 ? void 0 : result.getDate()).toBe(15);
+        });
+        // Date with time formats
+        it('should parse YYYY-MM-DD HH:mm:ss format', () => {
+            const dateStr = '2023-06-15 14:30:45';
+            const result = parseDate(dateStr, 'YYYY-MM-DD HH:mm:ss');
+            expect(result).toBeInstanceOf(Date);
+            expect(result === null || result === void 0 ? void 0 : result.getFullYear()).toBe(2023);
+            expect(result === null || result === void 0 ? void 0 : result.getMonth()).toBe(5);
+            expect(result === null || result === void 0 ? void 0 : result.getDate()).toBe(15);
+            expect(result === null || result === void 0 ? void 0 : result.getHours()).toBe(14);
+            expect(result === null || result === void 0 ? void 0 : result.getMinutes()).toBe(30);
+            expect(result === null || result === void 0 ? void 0 : result.getSeconds()).toBe(45);
+        });
+        // UTC handling
+        it('should handle UTC mode correctly', () => {
+            // Looking at the implementation, the 'Z' in the format tells parseDate
+            // to use UTC mode, but doesn't require the dateStr to have a Z
+            const isoString = '2023-06-15T14:30:45.000Z';
+            const result = parseDate(isoString, 'YYYY-MM-DDTHH:mm:ss.SSSZ');
+            expect(result.getFullYear()).toBe(2023);
+            expect(result.getMonth()).toBe(5); // June
+            expect(result.getDate()).toBe(15);
+        });
+        // Invalid date handling
+        it('should return null for invalid dates', () => {
+            const consoleSpy = vi
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            // Invalid day (June 31 doesn't exist)
+            const invalidDate = '2023-06-31';
+            const result = parseDate(invalidDate, 'YYYY-MM-DD');
+            expect(result).toBeNull();
+            expect(consoleSpy).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+        it("should return null when format doesn't match input", () => {
+            const consoleSpy = vi
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            // Format expects MM/DD/YYYY but input is YYYY-MM-DD
+            const mismatchFormat = '2023-06-15';
+            const result = parseDate(mismatchFormat, 'MM/DD/YYYY');
+            expect(result).toBeNull();
+            expect(consoleSpy).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+        // Edge cases
+        it('should handle leap years correctly', () => {
+            // February 29 in a leap year
+            const leapYearDate = '2024-02-29';
+            const result = parseDate(leapYearDate, 'YYYY-MM-DD');
+            expect(result).toBeInstanceOf(Date);
+            expect(result === null || result === void 0 ? void 0 : result.getFullYear()).toBe(2024);
+            expect(result === null || result === void 0 ? void 0 : result.getMonth()).toBe(1); // February
+            expect(result === null || result === void 0 ? void 0 : result.getDate()).toBe(29);
+        });
+        it('should handle daylight saving time transitions', () => {
+            // A date during DST transition (will depend on locale)
+            // This test might behave differently in different timezones
+            const dstDate = '2023-03-12 02:30:00'; // Around when DST starts in the US
+            const result = parseDate(dstDate, 'YYYY-MM-DD HH:mm:ss');
+            expect(result).toBeInstanceOf(Date);
+            // We're not checking specific times because behavior varies by timezone
+            // Just ensuring it parses to a valid date
+            expect(result === null || result === void 0 ? void 0 : result.getFullYear()).toBe(2023);
+            expect(result === null || result === void 0 ? void 0 : result.getMonth()).toBe(2); // March
+            expect(result === null || result === void 0 ? void 0 : result.getDate()).toBe(12);
+        });
+        // Test complex formats
+        it('should parse formats with month names and AM/PM markers', () => {
+            // Dayjs supports these format tokens, but not the ordinal 'Do'
+            // or day names like 'dddd' in strict mode
+            const dateStr = 'June 15 2023, 2:30:45 PM';
+            const format = 'MMMM D YYYY, h:mm:ss A';
+            const result = parseDate(dateStr, format);
+            expect(result).toBeInstanceOf(Date);
+            expect(result === null || result === void 0 ? void 0 : result.getFullYear()).toBe(2023);
+            expect(result === null || result === void 0 ? void 0 : result.getMonth()).toBe(5); // June
+            expect(result === null || result === void 0 ? void 0 : result.getDate()).toBe(15);
+            expect(result === null || result === void 0 ? void 0 : result.getHours()).toBe(14); // 2 PM = 14:00
+            expect(result === null || result === void 0 ? void 0 : result.getMinutes()).toBe(30);
+            expect(result === null || result === void 0 ? void 0 : result.getSeconds()).toBe(45);
+        });
+    });
+    describe('isSameDate', () => {
+        // Test with local dates
+        it('should return true for identical local dates', () => {
+            const date1 = new Date(2023, 5, 15, 10, 30, 0); // June 15, 2023, 10:30:00
+            const date2 = new Date(2023, 5, 15, 14, 45, 0); // June 15, 2023, 14:45:00 (different time)
+            const result = isSameDate(date1, date2, { isUTCMode: false });
+            expect(result).toBe(true);
+        });
+        it('should return false for different local dates', () => {
+            const date1 = new Date(2023, 5, 15); // June 15, 2023
+            const date2 = new Date(2023, 5, 16); // June 16, 2023
+            const result = isSameDate(date1, date2, { isUTCMode: false });
+            expect(result).toBe(false);
+        });
+        // Test with UTC dates
+        it('should return true for identical UTC dates', () => {
+            // Create dates with the same UTC date but different times
+            const date1 = new Date(Date.UTC(2023, 5, 15, 10, 30, 0)); // June 15, 2023, 10:30:00 UTC
+            const date2 = new Date(Date.UTC(2023, 5, 15, 14, 45, 0)); // June 15, 2023, 14:45:00 UTC
+            const result = isSameDate(date1, date2, { isUTCMode: true });
+            expect(result).toBe(true);
+        });
+        it('should return false for different UTC dates', () => {
+            const date1 = new Date(Date.UTC(2023, 5, 15)); // June 15, 2023 UTC
+            const date2 = new Date(Date.UTC(2023, 5, 16)); // June 16, 2023 UTC
+            const result = isSameDate(date1, date2, { isUTCMode: true });
+            expect(result).toBe(false);
+        });
+        // Test with dates that would be the same in one mode but different in another
+        it('should handle date differences across timezone boundaries when using local mode', () => {
+            // Create a date near midnight in UTC
+            const date1 = new Date(Date.UTC(2023, 5, 15, 23, 0, 0)); // June 15, 2023, 23:00 UTC
+            // This could be June 16 in local time depending on timezone
+            const date2 = new Date(date1);
+            date2.setUTCHours(date1.getUTCHours() + 2); // June 16, 2023, 01:00 UTC
+            // In local mode, these might be the same date depending on timezone
+            // We're just checking that the function respects the isUTCMode flag
+            const localResult = isSameDate(date1, date2, { isUTCMode: false });
+            const utcResult = isSameDate(date1, date2, { isUTCMode: true });
+            // The dates should be different in UTC mode (since we crossed UTC midnight)
+            expect(utcResult).toBe(false);
+            // The local result will depend on timezone, but we're just verifying
+            // that the function uses the correct getters based on isUTCMode
+            if (date1.getDate() === date2.getDate()) {
+                expect(localResult).toBe(true);
+            }
+            else {
+                expect(localResult).toBe(false);
+            }
+        });
+        // Test null handling
+        it('should return false if either date is null', () => {
+            const date = new Date(2023, 5, 15);
+            expect(isSameDate(null, date, { isUTCMode: false })).toBe(false);
+            expect(isSameDate(date, null, { isUTCMode: false })).toBe(false);
+            expect(isSameDate(null, null, { isUTCMode: false })).toBe(false);
+        });
+        // Test that the function only compares the date part
+        it('should ignore time differences in local mode', () => {
+            const morning = new Date(2023, 5, 15, 8, 0, 0); // 8:00 AM
+            const evening = new Date(2023, 5, 15, 20, 0, 0); // 8:00 PM
+            const result = isSameDate(morning, evening, { isUTCMode: false });
+            expect(result).toBe(true);
+        });
+        it('should ignore time differences in UTC mode', () => {
+            const morning = new Date(Date.UTC(2023, 5, 15, 8, 0, 0)); // 8:00 AM UTC
+            const evening = new Date(Date.UTC(2023, 5, 15, 20, 0, 0)); // 8:00 PM UTC
+            const result = isSameDate(morning, evening, { isUTCMode: true });
+            expect(result).toBe(true);
+        });
+        // Test edge cases
+        it('should correctly handle month/year boundaries', () => {
+            const lastDayOfMonth = new Date(2023, 5, 30); // June 30, 2023
+            const firstDayOfNextMonth = new Date(2023, 6, 1); // July 1, 2023
+            expect(isSameDate(lastDayOfMonth, firstDayOfNextMonth, { isUTCMode: false })).toBe(false);
+            const lastDayOfYear = new Date(2023, 11, 31); // December 31, 2023
+            const firstDayOfNextYear = new Date(2024, 0, 1); // January 1, 2024
+            expect(isSameDate(lastDayOfYear, firstDayOfNextYear, { isUTCMode: false })).toBe(false);
+        });
+        it('should handle leap year dates', () => {
+            const leapYearDay = new Date(2024, 1, 29); // February 29, 2024 (leap year)
+            const nonLeapYearDay = new Date(2023, 1, 28); // February 28, 2023 (non-leap year)
+            expect(isSameDate(leapYearDay, nonLeapYearDay, { isUTCMode: false })).toBe(false);
+        });
+    });
+    describe('isSameOrAfter', () => {
+        // Test cases for local mode (isUTCMode: false)
+        it('should return true when the date is the same in local mode', () => {
+            const date1 = new Date(2023, 5, 15, 10, 30); // June 15, 2023, 10:30
+            const date2 = new Date(2023, 5, 15, 14, 45); // June 15, 2023, 14:45 (same date, different time)
+            const result = isSameOrAfter(date1, date2, { isUTCMode: false });
+            // Should return true because the dates are the same (ignoring time)
+            expect(result).toBe(true);
+        });
+        it('should return true when the date is after in local mode', () => {
+            const later = new Date(2023, 5, 16); // June 16, 2023
+            const earlier = new Date(2023, 5, 15); // June 15, 2023
+            const result = isSameOrAfter(later, earlier, { isUTCMode: false });
+            expect(result).toBe(true);
+        });
+        it('should return false when the date is before in local mode', () => {
+            const earlier = new Date(2023, 5, 15); // June 15, 2023
+            const later = new Date(2023, 5, 16); // June 16, 2023
+            const result = isSameOrAfter(earlier, later, { isUTCMode: false });
+            expect(result).toBe(false);
+        });
+        // Test cases for UTC mode (isUTCMode: true)
+        it('should return true when the date is the same in UTC mode', () => {
+            const date1 = new Date(Date.UTC(2023, 5, 15, 10, 30)); // June 15, 2023, 10:30 UTC
+            const date2 = new Date(Date.UTC(2023, 5, 15, 14, 45)); // June 15, 2023, 14:45 UTC (same date, different time)
+            const result = isSameOrAfter(date1, date2, { isUTCMode: true });
+            // Should return true because the dates are the same (ignoring time)
+            expect(result).toBe(true);
+        });
+        it('should return true when the date is after in UTC mode', () => {
+            const later = new Date(Date.UTC(2023, 5, 16)); // June 16, 2023 UTC
+            const earlier = new Date(Date.UTC(2023, 5, 15)); // June 15, 2023 UTC
+            const result = isSameOrAfter(later, earlier, { isUTCMode: true });
+            expect(result).toBe(true);
+        });
+        it('should return false when the date is before in UTC mode', () => {
+            const earlier = new Date(Date.UTC(2023, 5, 15)); // June 15, 2023 UTC
+            const later = new Date(Date.UTC(2023, 5, 16)); // June 16, 2023 UTC
+            const result = isSameOrAfter(earlier, later, { isUTCMode: true });
+            expect(result).toBe(false);
+        });
+        // Test cases for different years and months
+        it('should return true when the year is after in local mode', () => {
+            const laterYear = new Date(2024, 0, 1); // January 1, 2024
+            const earlierYear = new Date(2023, 11, 31); // December 31, 2023
+            const result = isSameOrAfter(laterYear, earlierYear, {
+                isUTCMode: false,
+            });
+            expect(result).toBe(true);
+        });
+        it('should return true when the month is after in the same year in local mode', () => {
+            const laterMonth = new Date(2023, 6, 1); // July 1, 2023
+            const earlierMonth = new Date(2023, 5, 30); // June 30, 2023
+            const result = isSameOrAfter(laterMonth, earlierMonth, {
+                isUTCMode: false,
+            });
+            expect(result).toBe(true);
+        });
+        it('should return false when the year is before in UTC mode', () => {
+            const earlierYear = new Date(Date.UTC(2022, 11, 31)); // December 31, 2022 UTC
+            const laterYear = new Date(Date.UTC(2023, 0, 1)); // January 1, 2023 UTC
+            const result = isSameOrAfter(earlierYear, laterYear, { isUTCMode: true });
+            expect(result).toBe(false);
+        });
+        it('should return false when the month is before in the same year in UTC mode', () => {
+            const earlierMonth = new Date(Date.UTC(2023, 4, 31)); // May 31, 2023 UTC
+            const laterMonth = new Date(Date.UTC(2023, 5, 1)); // June 1, 2023 UTC
+            const result = isSameOrAfter(earlierMonth, laterMonth, {
+                isUTCMode: true,
+            });
+            expect(result).toBe(false);
+        });
+        // Edge cases
+        it('should handle same date with different times correctly in local mode', () => {
+            const morningDate = new Date(2023, 5, 15, 8, 0); // June 15, 2023, 8:00 AM
+            const eveningDate = new Date(2023, 5, 15, 20, 0); // June 15, 2023, 8:00 PM
+            // Since we're only comparing dates (not times), both should be "same or after" each other
+            expect(isSameOrAfter(morningDate, eveningDate, { isUTCMode: false })).toBe(true);
+            expect(isSameOrAfter(eveningDate, morningDate, { isUTCMode: false })).toBe(true);
+        });
+        it('should handle same date with different times correctly in UTC mode', () => {
+            const morningDate = new Date(Date.UTC(2023, 5, 15, 8, 0)); // June 15, 2023, 8:00 AM UTC
+            const eveningDate = new Date(Date.UTC(2023, 5, 15, 20, 0)); // June 15, 2023, 8:00 PM UTC
+            // Since we're only comparing dates (not times), both should be "same or after" each other
+            expect(isSameOrAfter(morningDate, eveningDate, { isUTCMode: true })).toBe(true);
+            expect(isSameOrAfter(eveningDate, morningDate, { isUTCMode: true })).toBe(true);
+        });
+        it('should handle leap year dates correctly', () => {
+            const leapYearDate = new Date(2024, 1, 29); // February 29, 2024 (leap year)
+            const nonLeapYearDate = new Date(2023, 1, 28); // February 28, 2023 (non-leap year)
+            // A date in a later year should be "after" regardless of the month/day
+            expect(isSameOrAfter(leapYearDate, nonLeapYearDate, { isUTCMode: false })).toBe(true);
+            expect(isSameOrAfter(nonLeapYearDate, leapYearDate, { isUTCMode: false })).toBe(false);
+        });
+        it('should handle edge cases between months correctly', () => {
+            const lastDayOfMonth = new Date(2023, 5, 30); // June 30, 2023
+            const firstDayOfNextMonth = new Date(2023, 6, 1); // July 1, 2023
+            expect(isSameOrAfter(lastDayOfMonth, firstDayOfNextMonth, {
+                isUTCMode: false,
+            })).toBe(false);
+            expect(isSameOrAfter(firstDayOfNextMonth, lastDayOfMonth, {
+                isUTCMode: false,
+            })).toBe(true);
+        });
+        it('should handle null dates gracefully', () => {
+            const date = new Date(2023, 5, 15);
+            const nullDate = null;
+            // Check if the function handles null inputs gracefully
+            // Note: Your implementation might need to be updated to handle this case
+            expect(() => isSameOrAfter(date, nullDate, { isUTCMode: false })).not.toThrow();
+            expect(() => isSameOrAfter(nullDate, date, { isUTCMode: false })).not.toThrow();
+        });
+    });
+    describe('isSameOrBefore', () => {
+        // Test cases for local mode (isUTCMode: false)
+        it('should return true when the date is the same in local mode', () => {
+            const date1 = new Date(2023, 5, 15, 10, 30); // June 15, 2023, 10:30
+            const date2 = new Date(2023, 5, 15, 14, 45); // June 15, 2023, 14:45 (same date, different time)
+            const result = isSameOrBefore(date1, date2, { isUTCMode: false });
+            // Should return true because the dates are the same (ignoring time)
+            expect(result).toBe(true);
+        });
+        it('should return true when the date is before in local mode', () => {
+            const earlier = new Date(2023, 5, 15); // June 15, 2023
+            const later = new Date(2023, 5, 16); // June 16, 2023
+            const result = isSameOrBefore(earlier, later, { isUTCMode: false });
+            expect(result).toBe(true);
+        });
+        it('should return false when the date is after in local mode', () => {
+            const later = new Date(2023, 5, 16); // June 16, 2023
+            const earlier = new Date(2023, 5, 15); // June 15, 2023
+            const result = isSameOrBefore(later, earlier, { isUTCMode: false });
+            expect(result).toBe(false);
+        });
+        // Test cases for UTC mode (isUTCMode: true)
+        it('should return true when the date is the same in UTC mode', () => {
+            const date1 = new Date(Date.UTC(2023, 5, 15, 10, 30)); // June 15, 2023, 10:30 UTC
+            const date2 = new Date(Date.UTC(2023, 5, 15, 14, 45)); // June 15, 2023, 14:45 UTC (same date, different time)
+            const result = isSameOrBefore(date1, date2, { isUTCMode: true });
+            // Should return true because the dates are the same (ignoring time)
+            expect(result).toBe(true);
+        });
+        it('should return true when the date is before in UTC mode', () => {
+            const earlier = new Date(Date.UTC(2023, 5, 15)); // June 15, 2023 UTC
+            const later = new Date(Date.UTC(2023, 5, 16)); // June 16, 2023 UTC
+            const result = isSameOrBefore(earlier, later, { isUTCMode: true });
+            expect(result).toBe(true);
+        });
+        it('should return false when the date is after in UTC mode', () => {
+            const later = new Date(Date.UTC(2023, 5, 16)); // June 16, 2023 UTC
+            const earlier = new Date(Date.UTC(2023, 5, 15)); // June 15, 2023 UTC
+            const result = isSameOrBefore(later, earlier, { isUTCMode: true });
+            expect(result).toBe(false);
+        });
+        // Test cases for different years and months
+        it('should return true when the year is before in local mode', () => {
+            const earlierYear = new Date(2022, 11, 31); // December 31, 2022
+            const laterYear = new Date(2023, 0, 1); // January 1, 2023
+            const result = isSameOrBefore(earlierYear, laterYear, {
+                isUTCMode: false,
+            });
+            expect(result).toBe(true);
+        });
+        it('should return true when the month is before in the same year in local mode', () => {
+            const earlierMonth = new Date(2023, 4, 31); // May 31, 2023
+            const laterMonth = new Date(2023, 5, 1); // June 1, 2023
+            const result = isSameOrBefore(earlierMonth, laterMonth, {
+                isUTCMode: false,
+            });
+            expect(result).toBe(true);
+        });
+        it('should return false when the year is after in UTC mode', () => {
+            const laterYear = new Date(Date.UTC(2023, 0, 1)); // January 1, 2023 UTC
+            const earlierYear = new Date(Date.UTC(2022, 11, 31)); // December 31, 2022 UTC
+            const result = isSameOrBefore(laterYear, earlierYear, {
+                isUTCMode: true,
+            });
+            expect(result).toBe(false);
+        });
+        it('should return false when the month is after in the same year in UTC mode', () => {
+            const laterMonth = new Date(Date.UTC(2023, 5, 1)); // June 1, 2023 UTC
+            const earlierMonth = new Date(Date.UTC(2023, 4, 31)); // May 31, 2023 UTC
+            const result = isSameOrBefore(laterMonth, earlierMonth, {
+                isUTCMode: true,
+            });
+            expect(result).toBe(false);
+        });
+        // Edge cases
+        it('should handle same date with different times correctly in local mode', () => {
+            const morningDate = new Date(2023, 5, 15, 8, 0); // June 15, 2023, 8:00 AM
+            const eveningDate = new Date(2023, 5, 15, 20, 0); // June 15, 2023, 8:00 PM
+            // Since we're only comparing dates (not times), both should be "same or before" each other
+            expect(isSameOrBefore(morningDate, eveningDate, { isUTCMode: false })).toBe(true);
+            expect(isSameOrBefore(eveningDate, morningDate, { isUTCMode: false })).toBe(true);
+        });
+        it('should handle same date with different times correctly in UTC mode', () => {
+            const morningDate = new Date(Date.UTC(2023, 5, 15, 8, 0)); // June 15, 2023, 8:00 AM UTC
+            const eveningDate = new Date(Date.UTC(2023, 5, 15, 20, 0)); // June 15, 2023, 8:00 PM UTC
+            // Since we're only comparing dates (not times), both should be "same or before" each other
+            expect(isSameOrBefore(morningDate, eveningDate, { isUTCMode: true })).toBe(true);
+            expect(isSameOrBefore(eveningDate, morningDate, { isUTCMode: true })).toBe(true);
+        });
+        it('should handle leap year dates correctly', () => {
+            const leapYearDate = new Date(2024, 1, 29); // February 29, 2024 (leap year)
+            const nonLeapYearDate = new Date(2023, 1, 28); // February 28, 2023 (non-leap year)
+            // A date in an earlier year should be "before" regardless of the month/day
+            expect(isSameOrBefore(nonLeapYearDate, leapYearDate, { isUTCMode: false })).toBe(true);
+            expect(isSameOrBefore(leapYearDate, nonLeapYearDate, { isUTCMode: false })).toBe(false);
+        });
+        it('should handle edge cases between months correctly', () => {
+            const lastDayOfMonth = new Date(2023, 5, 30); // June 30, 2023
+            const firstDayOfNextMonth = new Date(2023, 6, 1); // July 1, 2023
+            expect(isSameOrBefore(lastDayOfMonth, firstDayOfNextMonth, {
+                isUTCMode: false,
+            })).toBe(true);
+            expect(isSameOrBefore(firstDayOfNextMonth, lastDayOfMonth, {
+                isUTCMode: false,
+            })).toBe(false);
+        });
+        it('should handle null dates gracefully', () => {
+            const date = new Date(2023, 5, 15);
+            const nullDate = null;
+            // The function already has null checks, so these should return false
+            expect(isSameOrBefore(date, nullDate, { isUTCMode: false })).toBe(false);
+            expect(isSameOrBefore(nullDate, date, { isUTCMode: false })).toBe(false);
+            expect(isSameOrBefore(nullDate, nullDate, { isUTCMode: false })).toBe(false);
+        });
+    });
+    describe('formatDate', () => {
+        // Basic test for null input
+        it('should return empty string for null date', () => {
+            expect(formatDate(null, { dateFormat: 'YYYY-MM-DD' })).toBe('');
+        });
+        // ISO 8601 format
+        it('should format using toISOString() for ISO 8601 format', () => {
+            const date = new Date(2023, 5, 15, 12, 30, 45, 123); // June 15, 2023, 12:30:45.123
+            const result = formatDate(date, {
+                dateFormat: 'YYYY-MM-DD[T]HH:mm:ss[Z]',
+            });
+            expect(result).toBe(date.toISOString());
+        });
+        // Ticks format
+        it('should convert to C# ticks for "Ticks" format', () => {
+            const date = new Date(2023, 5, 15); // June 15, 2023
+            const milliseconds = date.getTime();
+            const expectedTicks = milliseconds * 10000 + 621355968000000000;
+            const result = formatDate(date, { dateFormat: 'Ticks' });
+            expect(result).toBe(expectedTicks.toString());
+        });
+        // Unix seconds format
+        it('should convert to Unix seconds for "X" format', () => {
+            const date = new Date(2023, 5, 15); // June 15, 2023
+            const unixSeconds = Math.floor(date.getTime() / 1000);
+            const result = formatDate(date, { dateFormat: 'X' });
+            expect(result).toBe(unixSeconds.toString());
+        });
+        // Unix milliseconds format
+        it('should convert to Unix milliseconds for "x" format', () => {
+            const date = new Date(2023, 5, 15); // June 15, 2023
+            const milliseconds = date.getTime();
+            const result = formatDate(date, { dateFormat: 'x' });
+            expect(result).toBe(milliseconds.toString());
+        });
+        // Standard date formats in local mode
+        it('should format date according to "YYYY-MM-DD" format in local mode', () => {
+            const date = new Date(2023, 5, 15); // June 15, 2023
+            const expected = '2023-06-15';
+            const result = formatDate(date, { dateFormat: 'YYYY-MM-DD' });
+            expect(result).toBe(expected);
+        });
+        it('should format date according to "DD/MM/YYYY" format in local mode', () => {
+            const date = new Date(2023, 5, 15); // June 15, 2023
+            const expected = '15/06/2023';
+            const result = formatDate(date, { dateFormat: 'DD/MM/YYYY' });
+            expect(result).toBe(expected);
+        });
+        it('should format date according to "MM-DD-YYYY" format in local mode', () => {
+            const date = new Date(2023, 5, 15); // June 15, 2023
+            const expected = '06-15-2023';
+            const result = formatDate(date, { dateFormat: 'MM-DD-YYYY' });
+            expect(result).toBe(expected);
+        });
+        // Date formats with time in local mode
+        it('should format date and time in local mode', () => {
+            const date = new Date(2023, 5, 15, 14, 30, 45); // June 15, 2023, 14:30:45
+            const expected = '2023-06-15 14:30:45';
+            const result = formatDate(date, { dateFormat: 'YYYY-MM-DD HH:mm:ss' });
+            expect(result).toBe(expected);
+        });
+        // Standard date formats in UTC mode
+        it('should format date according to format in UTC mode', () => {
+            const date = new Date(Date.UTC(2023, 5, 15, 14, 30, 45)); // June 15, 2023, 14:30:45 UTC
+            // When 'Z' is in the format, dayjs adds the timezone offset (+00:00)
+            const expected = '2023-06-15+00:00';
+            const result = formatDate(date, { dateFormat: 'YYYY-MM-DDZ' });
+            expect(result).toBe(expected);
+        });
+        // Date formats with time in UTC mode
+        it('should format date and time in UTC mode', () => {
+            // Create a specific date with known UTC time
+            const date = new Date(Date.UTC(2023, 5, 15, 14, 30, 45)); // June 15, 2023, 14:30:45 UTC
+            // When 'Z' is in the format, dayjs adds the timezone offset (+00:00)
+            const expected = '2023-06-15 14:30:45+00:00';
+            const result = formatDate(date, { dateFormat: 'YYYY-MM-DD HH:mm:ssZ' });
+            expect(result).toBe(expected);
+        });
+        // Test with 12-hour format
+        it('should format date with AM/PM markers', () => {
+            const morningDate = new Date(2023, 5, 15, 9, 30); // June 15, 2023, 9:30 AM
+            const eveningDate = new Date(2023, 5, 15, 21, 30); // June 15, 2023, 9:30 PM
+            const morningResult = formatDate(morningDate, { dateFormat: 'hh:mm A' });
+            const eveningResult = formatDate(eveningDate, { dateFormat: 'hh:mm A' });
+            expect(morningResult).toBe('09:30 AM');
+            expect(eveningResult).toBe('09:30 PM');
+        });
+        // Test with month name format
+        it('should format date with month names', () => {
+            const date = new Date(2023, 5, 15); // June 15, 2023
+            const resultFull = formatDate(date, { dateFormat: 'MMMM D, YYYY' });
+            const resultAbbr = formatDate(date, { dateFormat: 'MMM D, YYYY' });
+            expect(resultFull).toBe('June 15, 2023');
+            expect(resultAbbr).toBe('Jun 15, 2023');
+        });
+        // Test with day of week format
+        it('should format date with day of week', () => {
+            const date = new Date(2023, 5, 15); // June 15, 2023, was a Thursday
+            const resultFull = formatDate(date, { dateFormat: 'dddd, MMMM D, YYYY' });
+            const resultAbbr = formatDate(date, { dateFormat: 'ddd, MMM D, YYYY' });
+            expect(resultFull).toBe('Thursday, June 15, 2023');
+            expect(resultAbbr).toBe('Thu, Jun 15, 2023');
+        });
+        // Edge cases
+        it('should handle leap year dates', () => {
+            const leapYearDate = new Date(2024, 1, 29); // February 29, 2024 (leap year)
+            const result = formatDate(leapYearDate, { dateFormat: 'YYYY-MM-DD' });
+            expect(result).toBe('2024-02-29');
+        });
+        it('should handle historic dates', () => {
+            const historicDate = new Date(1776, 6, 4); // July 4, 1776
+            const result = formatDate(historicDate, { dateFormat: 'MMMM D, YYYY' });
+            expect(result).toBe('July 4, 1776');
+        });
+        it('should handle future dates', () => {
+            const futureDate = new Date(2100, 11, 31); // December 31, 2100
+            const result = formatDate(futureDate, { dateFormat: 'YYYY-MM-DD' });
+            expect(result).toBe('2100-12-31');
+        });
+    });
+});
+//# sourceMappingURL=nv-calendar.utils.test.js.map