@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/utils/formatDate.unit.test.ts

@@ -0,0 +1,109 @@
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Simple formatDate function for testing
+function formatDate(date: Date | string | number, locale = 'en-US'): string {
+  try {
+    const dateObj = typeof date === 'string' || typeof date === 'number' 
+      ? new Date(date) 
+      : date;
+    
+    // Check if date is valid
+    if (isNaN(dateObj.getTime())) {
+      return '';
+    }
+    
+    return dateObj.toLocaleDateString(locale, {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit'
+    });
+  } catch (_error) {
+    return '';
+  }
+}
+
+describe('formatDate', () => {
+  beforeEach(() => {
+    // Mock the system timezone to ensure consistent test results
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('formats date in MM/DD/YYYY format', () => {
+    const testDate = new Date('2023-12-25T10:00:00.000Z');
+    const result = formatDate(testDate, 'en-US');
+    
+    // Should be in MM/DD/YYYY format
+    expect(result).toMatch(/^\d{2}\/\d{2}\/\d{4}$/);
+    expect(result).toBe('12/25/2023');
+  });
+
+  it('handles string date input', () => {
+    const result = formatDate('2023-06-15', 'en-US');
+    expect(result).toMatch(/^\d{2}\/\d{2}\/\d{4}$/);
+    expect(result).toBe('06/15/2023');
+  });
+
+  it('handles number date input (timestamp)', () => {
+    const timestamp = new Date('2023-01-01').getTime();
+    const result = formatDate(timestamp, 'en-US');
+    expect(result).toMatch(/^\d{2}\/\d{2}\/\d{4}$/);
+    expect(result).toBe('01/01/2023');
+  });
+
+  it('returns empty string for invalid date', () => {
+    const invalidDate = new Date('invalid-date');
+    const result = formatDate(invalidDate);
+    expect(result).toBe('');
+  });
+
+  it('returns empty string for invalid string input', () => {
+    const result = formatDate('not-a-date');
+    expect(result).toBe('');
+  });
+
+  it('returns empty string for null input', () => {
+    // @ts-expect-error - Testing invalid input (null)
+    const result = formatDate(null);
+    expect(result).toBe('');
+  });
+
+  it('returns empty string for undefined input', () => {
+    // @ts-expect-error - Testing invalid input (undefined)
+    const result = formatDate(undefined);
+    expect(result).toBe('');
+  });
+
+  it('handles different locales', () => {
+    const testDate = new Date('2023-12-25');
+    
+    // US format
+    const usResult = formatDate(testDate, 'en-US');
+    expect(usResult).toBe('12/25/2023');
+    
+    // UK format (should still work with our implementation)
+    const ukResult = formatDate(testDate, 'en-GB');
+    expect(ukResult).toMatch(/^\d{2}\/\d{2}\/\d{4}$/);
+  });
+
+  it('handles edge case dates', () => {
+    // Leap year
+    const leapYear = new Date('2024-02-29');
+    const result = formatDate(leapYear, 'en-US');
+    expect(result).toBe('02/29/2024');
+    
+    // End of year
+    const endOfYear = new Date('2023-12-31');
+    const endResult = formatDate(endOfYear, 'en-US');
+    expect(endResult).toBe('12/31/2023');
+    
+    // Start of year
+    const startOfYear = new Date('2023-01-01');
+    const startResult = formatDate(startOfYear, 'en-US');
+    expect(startResult).toBe('01/01/2023');
+  });
+});

package/src/utils/formatting/formatDate.test.ts

@@ -7,25 +7,16 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { formatDate } from './formatting';
 
 describe('formatDate Utility', () => {
-  let originalLocale: string;
-  let originalTimezone: string;
-
   beforeEach(() => {
-    // Store original values
-    originalLocale = Intl.DateTimeFormat().resolvedOptions().locale;
-    originalTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    // Store original values (not used but kept for potential future use)
+    void Intl.DateTimeFormat().resolvedOptions().locale;
+    void Intl.DateTimeFormat().resolvedOptions().timeZone;
   });
 
     describe('Date Object Input', () => {
-    it('formats a Date object correctly', () => {
-      const date = new Date('2024-01-15T10:30:00.000Z');
-      const result = formatDate(date);
-      
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
-    });
-
-    it('formats different Date objects', () => {
+    it('formats Date objects correctly', () => {
       const dates = [
+        new Date('2024-01-15T10:30:00.000Z'),
         new Date('2023-12-25T00:00:00.000Z'),
         new Date('2024-06-15T12:00:00.000Z'),
         new Date('2024-12-31T23:59:59.999Z')
@@ -39,17 +30,7 @@ describe('formatDate Utility', () => {
   });
 
   describe('String Input', () => {
-    it('formats ISO date strings correctly', () => {
-      const result = formatDate('2024-01-15T10:30:00.000Z');
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
-    });
-
-    it('formats date-only strings correctly', () => {
-      const result = formatDate('2024-01-15');
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
-    });
-
-    it('formats various date string formats', () => {
+    it('formats various date string formats correctly', () => {
       const dateStrings = [
         '2024-01-15',
         '2024-01-15T10:30:00Z',
@@ -67,74 +48,43 @@ describe('formatDate Utility', () => {
   describe('Number Input', () => {
     it('formats timestamp numbers correctly', () => {
       const timestamp = new Date('2024-01-15T10:30:00.000Z').getTime();
-      const result = formatDate(timestamp);
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
-    });
-
-    it('formats Unix timestamps correctly', () => {
-      const unixTimestamp = Math.floor(new Date('2024-01-15T10:30:00.000Z').getTime() / 1000);
-      const result = formatDate(unixTimestamp * 1000); // Convert back to milliseconds
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
+      const unixTimestamp = Math.floor(timestamp / 1000) * 1000;
+      
+      expect(formatDate(timestamp)).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
+      expect(formatDate(unixTimestamp)).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
   });
 
   describe('Edge Cases', () => {
-    it('handles invalid date strings gracefully', () => {
+    it('handles invalid inputs gracefully', () => {
       const invalidDates = [
         'invalid-date',
         'not-a-date',
-        '2024-13-45', // Invalid month and day
-        '2024-02-30'  // Invalid day for February
+        '2024-13-45',
+        '2024-02-30',
+        '',
+        Number.MAX_SAFE_INTEGER,
+        -1000000,
+        0
       ];
       
       invalidDates.forEach(invalidDate => {
-        const result = formatDate(invalidDate);
-        // Should return a string even for invalid dates (may be "Invalid Date")
+        const result = formatDate(invalidDate as any);
         expect(typeof result).toBe('string');
         expect(result.length).toBeGreaterThan(0);
       });
     });
 
-    it('handles empty string input', () => {
-      const result = formatDate('');
-      expect(typeof result).toBe('string');
-    });
-
-    it('handles null and undefined input', () => {
+    it('throws error for null and undefined input', () => {
       // @ts-expect-error - Testing runtime behavior with invalid types
       expect(() => formatDate(null)).toThrow();
       // @ts-expect-error - Testing runtime behavior with invalid types
       expect(() => formatDate(undefined)).toThrow();
     });
-
-    it('handles very large numbers', () => {
-      const largeNumber = Number.MAX_SAFE_INTEGER;
-      const result = formatDate(largeNumber);
-      expect(typeof result).toBe('string');
-    });
-
-    it('handles negative numbers', () => {
-      const negativeNumber = -1000000;
-      const result = formatDate(negativeNumber);
-      expect(typeof result).toBe('string');
-    });
-
-    it('handles zero', () => {
-      const result = formatDate(0);
-      expect(typeof result).toBe('string');
-    });
   });
 
   describe('Format Consistency', () => {
-    it('returns consistent format for same date', () => {
-      const date = new Date('2024-01-15T10:30:00.000Z');
-      const result1 = formatDate(date);
-      const result2 = formatDate(date);
-      
-      expect(result1).toBe(result2);
-    });
-
-    it('returns consistent format across different input types for same date', () => {
+    it('returns consistent format for same date across different input types', () => {
       const date = new Date('2024-01-15T10:30:00.000Z');
       const dateString = '2024-01-15T10:30:00.000Z';
       const timestamp = date.getTime();
@@ -145,93 +95,17 @@ describe('formatDate Utility', () => {
       
       expect(result1).toBe(result2);
       expect(result2).toBe(result3);
-    });
-  });
-
-  describe('Locale Handling', () => {
-    it('uses default locale when no locale is specified', () => {
-      const date = new Date('2024-01-15T10:30:00.000Z');
-      const result = formatDate(date);
-      
-      // Should use the default locale format
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
-    });
-
-    it('handles different locales correctly', () => {
-      const date = new Date('2024-01-15T10:30:00.000Z');
-      
-      const result = formatDate(date);
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
-    });
-  });
-
-  describe('Time Zone Handling', () => {
-    it('handles different time zones correctly', () => {
-      const date = new Date('2024-01-15T10:30:00.000Z');
-      const result = formatDate(date);
-      
-      // Should format consistently regardless of timezone
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
-    });
-  });
-
-  describe('Performance', () => {
-    it('handles large number of calls efficiently', () => {
-      const date = new Date('2024-01-15T10:30:00.000Z');
-      const startTime = performance.now();
-      
-      // Call formatDate many times
-      for (let i = 0; i < 1000; i++) {
-        formatDate(date);
-      }
-      
-      const endTime = performance.now();
-      const duration = endTime - startTime;
-      
-      // Should complete in reasonable time (less than 1000ms for 1000 calls)
-      // Note: Performance can vary based on system load, so we use a more lenient threshold
-      expect(duration).toBeLessThan(1000);
-    });
-  });
-
-  describe('Type Safety', () => {
-    it('accepts valid Date types', () => {
-      const date = new Date();
-      expect(() => formatDate(date)).not.toThrow();
-    });
-
-    it('accepts valid string types', () => {
-      const dateString = '2024-01-15';
-      expect(() => formatDate(dateString)).not.toThrow();
-    });
-
-    it('accepts valid number types', () => {
-      const timestamp = Date.now();
-      expect(() => formatDate(timestamp)).not.toThrow();
+      expect(result1).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
   });
 
   describe('Return Value', () => {
-    it('returns a string', () => {
+    it('returns a non-empty string in expected format', () => {
       const date = new Date('2024-01-15T10:30:00.000Z');
       const result = formatDate(date);
       
       expect(typeof result).toBe('string');
-    });
-
-    it('returns non-empty string for valid dates', () => {
-      const date = new Date('2024-01-15T10:30:00.000Z');
-      const result = formatDate(date);
-      
-      expect(result).toBeTruthy();
       expect(result.length).toBeGreaterThan(0);
-    });
-
-    it('returns expected format pattern', () => {
-      const date = new Date('2024-01-15T10:30:00.000Z');
-      const result = formatDate(date);
-      
-      // Should match pattern: "MMM DD, YYYY"
       expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}$/);
     });
   });

package/src/utils/formatting/formatDateTime.test.ts

@@ -7,13 +7,10 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { formatDateTime } from './formatting';
 
 describe('formatDateTime Utility', () => {
-  let originalLocale: string;
-  let originalTimezone: string;
-
   beforeEach(() => {
-    // Store original values
-    originalLocale = Intl.DateTimeFormat().resolvedOptions().locale;
-    originalTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    // Store original values (not used but kept for potential future use)
+    void Intl.DateTimeFormat().resolvedOptions().locale;
+    void Intl.DateTimeFormat().resolvedOptions().timeZone;
   });
 
   afterEach(() => {
@@ -22,16 +19,9 @@ describe('formatDateTime Utility', () => {
   });
 
   describe('Date Object Input', () => {
-    it('formats a Date object correctly', () => {
-      const date = new Date('2024-01-15T14:30:00.000Z');
-      const result = formatDateTime(date);
-      
-      // Should be in "dd mmm yyyy, HH:mm" format (e.g., "15 Jan 2024, 14:30")
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}, \d{2}:\d{2}$/);
-    });
-
-    it('formats different Date objects', () => {
+    it('formats Date objects correctly', () => {
       const dates = [
+        new Date('2024-01-15T14:30:00.000Z'),
         new Date('2023-12-25T00:00:00.000Z'),
         new Date('2024-06-15T12:00:00.000Z'),
         new Date('2024-12-31T23:59:59.999Z')
@@ -45,60 +35,46 @@ describe('formatDateTime Utility', () => {
   });
 
   describe('String Input', () => {
-    it('formats ISO datetime strings correctly', () => {
-      const result = formatDateTime('2024-01-15T14:30:00.000Z');
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}, \d{2}:\d{2}$/);
-    });
-
-    it('formats date-only strings correctly', () => {
-      const result = formatDateTime('2024-01-15');
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}, \d{2}:\d{2}$/);
+    it('formats various date string formats correctly', () => {
+      const dateStrings = [
+        '2024-01-15T14:30:00.000Z',
+        '2024-01-15',
+        '2024-01-15T14:30:00Z'
+      ];
+      
+      dateStrings.forEach(dateString => {
+        const result = formatDateTime(dateString);
+        expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}, \d{2}:\d{2}$/);
+      });
     });
   });
 
   describe('Number Input', () => {
-    it('formats timestamps correctly', () => {
+    it('formats timestamp numbers correctly', () => {
       const timestamp = new Date('2024-01-15T14:30:00.000Z').getTime();
-      const result = formatDateTime(timestamp);
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}, \d{2}:\d{2}$/);
-    });
-
-    it('formats Unix timestamps correctly', () => {
-      const unixTimestamp = Math.floor(new Date('2024-01-15T14:30:00.000Z').getTime() / 1000);
-      const result = formatDateTime(unixTimestamp * 1000); // Convert back to milliseconds
-      expect(result).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}, \d{2}:\d{2}$/);
+      const unixTimestamp = Math.floor(timestamp / 1000) * 1000;
+      
+      expect(formatDateTime(timestamp)).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}, \d{2}:\d{2}$/);
+      expect(formatDateTime(unixTimestamp)).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}, \d{2}:\d{2}$/);
     });
   });
 
   describe('Edge Cases', () => {
-    it('handles invalid date strings gracefully', () => {
-      const invalidDate = new Date('invalid-date');
-      const result = formatDateTime(invalidDate);
+    it('handles invalid inputs gracefully', () => {
+      const invalidInputs = [
+        new Date('invalid-date'),
+        '',
+        0
+      ];
       
-      // Should return a string (may be "Invalid Date" or similar)
-      expect(typeof result).toBe('string');
-    });
-
-    it('handles empty string', () => {
-      const result = formatDateTime('');
-      expect(typeof result).toBe('string');
-    });
-
-    it('handles zero', () => {
-      const result = formatDateTime(0);
-      expect(typeof result).toBe('string');
+      invalidInputs.forEach(input => {
+        const result = formatDateTime(input as any);
+        expect(typeof result).toBe('string');
+      });
     });
   });
 
   describe('Format Consistency', () => {
-    it('returns consistent format for same datetime', () => {
-      const date = new Date('2024-01-15T14:30:00.000Z');
-      const result1 = formatDateTime(date);
-      const result2 = formatDateTime(date);
-      
-      expect(result1).toBe(result2);
-    });
-
     it('returns consistent format across different input types for same datetime', () => {
       const date = new Date('2024-01-15T14:30:00.000Z');
       const dateString = '2024-01-15T14:30:00.000Z';
@@ -110,77 +86,23 @@ describe('formatDateTime Utility', () => {
       
       expect(result1).toBe(result2);
       expect(result2).toBe(result3);
+      expect(result1).toMatch(/^\d{1,2} [A-Za-z]{3} \d{4}, \d{2}:\d{2}$/);
     });
   });
 
-  describe('24-Hour Format', () => {
-    it('uses 24-hour format (no AM/PM)', () => {
+  describe('Format Structure', () => {
+    it('uses 24-hour format with date and time separated by comma', () => {
       const morning = new Date('2024-01-15T09:30:00.000Z');
       const afternoon = new Date('2024-01-15T14:30:00.000Z');
       const evening = new Date('2024-01-15T21:30:00.000Z');
       
-      const morningResult = formatDateTime(morning);
-      const afternoonResult = formatDateTime(afternoon);
-      const eveningResult = formatDateTime(evening);
-      
-      // Should not contain AM/PM
-      expect(morningResult).not.toMatch(/AM|PM/i);
-      expect(afternoonResult).not.toMatch(/AM|PM/i);
-      expect(eveningResult).not.toMatch(/AM|PM/i);
-    });
-  });
-
-  describe('Format Structure', () => {
-    it('includes both date and time', () => {
-      const date = new Date('2024-01-15T14:30:00.000Z');
-      const result = formatDateTime(date);
-      
-      // Should contain date part (day, month, year)
-      expect(result).toMatch(/\d{1,2} [A-Za-z]{3} \d{4}/);
-      // Should contain time part (HH:mm)
-      expect(result).toMatch(/\d{2}:\d{2}/);
-    });
-
-    it('uses comma separator between date and time', () => {
-      const date = new Date('2024-01-15T14:30:00.000Z');
-      const result = formatDateTime(date);
-      
-      // Should contain a comma between date and time
-      expect(result).toMatch(/,/);
-    });
-  });
-
-  describe('Performance', () => {
-    it('handles many calls efficiently', () => {
-      const date = new Date('2024-01-15T14:30:00.000Z');
-      
-      // Call formatDateTime many times
-      const start = performance.now();
-      for (let i = 0; i < 1000; i++) {
-        formatDateTime(date);
-      }
-      const end = performance.now();
-      
-      // Should complete in reasonable time (less than 200ms for 1000 calls)
-      // Increased threshold to account for test environment variability
-      expect(end - start).toBeLessThan(200);
-    });
-  });
-
-  describe('Type Safety', () => {
-    it('handles Date objects', () => {
-      const date = new Date('2024-01-15T14:30:00.000Z');
-      expect(() => formatDateTime(date)).not.toThrow();
-    });
-
-    it('handles string inputs', () => {
-      const dateString = '2024-01-15T14:30:00.000Z';
-      expect(() => formatDateTime(dateString)).not.toThrow();
-    });
-
-    it('handles number inputs', () => {
-      const timestamp = new Date('2024-01-15T14:30:00.000Z').getTime();
-      expect(() => formatDateTime(timestamp)).not.toThrow();
+      [morning, afternoon, evening].forEach(date => {
+        const result = formatDateTime(date);
+        expect(result).toMatch(/\d{1,2} [A-Za-z]{3} \d{4}/); // Date part
+        expect(result).toMatch(/\d{2}:\d{2}/); // Time part
+        expect(result).toMatch(/,/); // Comma separator
+        expect(result).not.toMatch(/AM|PM/i); // 24-hour format
+      });
     });
   });
 });