@jmruthers/pace-core 0.6.9 → 0.6.11

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

@@ -1,7 +1,7 @@
 /**
  * @file Timezone-Aware Date Formatting Tests
  * @package @jmruthers/pace-core
- * @module Utils/Formatting/__tests__
+ * @module Utils/Formatting
  * @since 0.1.0
  *
  * Comprehensive tests for timezone-aware date formatting functions.
@@ -18,16 +18,13 @@ import {
 
 describe('Timezone-Aware Date Formatting', () => {
   describe('formatDateTimeForDisplay', () => {
-    it('formats UTC date with timezone abbreviation', () => {
-      const result = formatDateTimeForDisplay('2024-01-15T10:00:00Z', 'America/New_York');
-      expect(result).toMatch(/Jan 15, 2024/);
-      expect(result).toMatch(/\(/); // Should include timezone abbreviation in parentheses
-    });
-
-    it('formats Date object with timezone', () => {
-      const date = new Date('2024-01-15T10:00:00Z');
-      const result = formatDateTimeForDisplay(date, 'America/New_York');
-      expect(result).toMatch(/Jan 15, 2024/);
+    it('formats dates with timezone abbreviation', () => {
+      const dateString = '2024-01-15T10:00:00Z';
+      const date = new Date(dateString);
+      
+      expect(formatDateTimeForDisplay(dateString, 'America/New_York')).toMatch(/Jan 15, 2024/);
+      expect(formatDateTimeForDisplay(date, 'America/New_York')).toMatch(/Jan 15, 2024/);
+      expect(formatDateTimeForDisplay(dateString, 'America/New_York')).toMatch(/\(/); // Should include timezone abbreviation in parentheses
     });
 
     it('excludes timezone when includeTimezone is false', () => {
@@ -43,19 +40,10 @@ describe('Timezone-Aware Date Formatting', () => {
       expect(result).toMatch(/2024-01-15/);
     });
 
-    it('returns empty string for undefined date', () => {
-      const result = formatDateTimeForDisplay(undefined, 'America/New_York');
-      expect(result).toBe('');
-    });
-
-    it('returns empty string for undefined timezone', () => {
-      const result = formatDateTimeForDisplay('2024-01-15T10:00:00Z', undefined);
-      expect(result).toBe('');
-    });
-
-    it('returns empty string for invalid date', () => {
-      const result = formatDateTimeForDisplay('invalid-date', 'America/New_York');
-      expect(result).toBe('');
+    it('returns empty string for invalid inputs', () => {
+      expect(formatDateTimeForDisplay(undefined, 'America/New_York')).toBe('');
+      expect(formatDateTimeForDisplay('2024-01-15T10:00:00Z', undefined)).toBe('');
+      expect(formatDateTimeForDisplay('invalid-date', 'America/New_York')).toBe('');
     });
 
     it('handles different timezones correctly', () => {
@@ -68,26 +56,18 @@ describe('Timezone-Aware Date Formatting', () => {
 
   describe('formatDateOnlyForDisplay', () => {
     it('formats date only without time', () => {
-      const result = formatDateOnlyForDisplay('2024-01-15T10:00:00Z');
-      expect(result).toMatch(/January/);
-      expect(result).toMatch(/2024/);
-      expect(result).toMatch(/15/);
-    });
-
-    it('formats Date object', () => {
-      const date = new Date('2024-01-15T10:00:00Z');
-      const result = formatDateOnlyForDisplay(date);
-      expect(result).toMatch(/January/);
+      const dateString = '2024-01-15T10:00:00Z';
+      const date = new Date(dateString);
+      
+      expect(formatDateOnlyForDisplay(dateString)).toMatch(/January/);
+      expect(formatDateOnlyForDisplay(dateString)).toMatch(/2024/);
+      expect(formatDateOnlyForDisplay(dateString)).toMatch(/15/);
+      expect(formatDateOnlyForDisplay(date)).toMatch(/January/);
     });
 
-    it('returns empty string for undefined', () => {
-      const result = formatDateOnlyForDisplay(undefined);
-      expect(result).toBe('');
-    });
-
-    it('returns empty string for invalid date', () => {
-      const result = formatDateOnlyForDisplay('invalid-date');
-      expect(result).toBe('');
+    it('returns empty string for invalid inputs', () => {
+      expect(formatDateOnlyForDisplay(undefined)).toBe('');
+      expect(formatDateOnlyForDisplay('invalid-date')).toBe('');
     });
 
     it('formats different dates correctly', () => {
@@ -107,60 +87,36 @@ describe('Timezone-Aware Date Formatting', () => {
 
   describe('formatDateTimeForTable', () => {
     it('formats date for table display with timezone', () => {
-      const result = formatDateTimeForTable('2024-01-15T10:00:00Z', 'America/New_York');
-      expect(result).toMatch(/Jan 15, 2024/);
-      expect(result).toMatch(/\(/); // Should include timezone
+      const dateString = '2024-01-15T10:00:00Z';
+      const date = new Date(dateString);
+      
+      expect(formatDateTimeForTable(dateString, 'America/New_York')).toMatch(/Jan 15, 2024/);
+      expect(formatDateTimeForTable(dateString, 'America/New_York')).toMatch(/\(/); // Should include timezone
+      expect(formatDateTimeForTable(date, 'America/New_York')).toMatch(/Jan 15, 2024/);
     });
 
-    it('returns empty string for undefined date', () => {
-      const result = formatDateTimeForTable(undefined, 'America/New_York');
-      expect(result).toBe('');
-    });
-
-    it('returns empty string for undefined timezone', () => {
-      const result = formatDateTimeForTable('2024-01-15T10:00:00Z', undefined);
-      expect(result).toBe('');
-    });
-
-    it('formats Date object', () => {
-      const date = new Date('2024-01-15T10:00:00Z');
-      const result = formatDateTimeForTable(date, 'America/New_York');
-      expect(result).toMatch(/Jan 15, 2024/);
+    it('returns empty string for invalid inputs', () => {
+      expect(formatDateTimeForTable(undefined, 'America/New_York')).toBe('');
+      expect(formatDateTimeForTable('2024-01-15T10:00:00Z', undefined)).toBe('');
     });
   });
 
   describe('formatDateTimeForMap', () => {
-    it('formats date for map display', () => {
-      const result = formatDateTimeForMap('2024-01-15T10:00:00Z', 'America/New_York');
+    it('formats date for map display with timezone', () => {
+      const dateString = '2024-01-15T10:00:00Z';
+      const date = new Date(dateString);
+      const result = formatDateTimeForMap(dateString, 'America/New_York');
+      
       expect(result).toMatch(/Jan 15/);
       expect(result).toMatch(/\d{2}:\d{2}/); // Time format
-    });
-
-    it('includes timezone abbreviation', () => {
-      const result = formatDateTimeForMap('2024-01-15T10:00:00Z', 'America/New_York');
       expect(result.length).toBeGreaterThan(0);
-      // Should include timezone info (not in parentheses for map format)
-    });
-
-    it('returns empty string for undefined date', () => {
-      const result = formatDateTimeForMap(undefined, 'America/New_York');
-      expect(result).toBe('');
-    });
-
-    it('returns empty string for undefined timezone', () => {
-      const result = formatDateTimeForMap('2024-01-15T10:00:00Z', undefined);
-      expect(result).toBe('');
-    });
-
-    it('formats Date object', () => {
-      const date = new Date('2024-01-15T10:00:00Z');
-      const result = formatDateTimeForMap(date, 'America/New_York');
-      expect(result).toMatch(/Jan 15/);
+      expect(formatDateTimeForMap(date, 'America/New_York')).toMatch(/Jan 15/);
     });
 
-    it('returns empty string for invalid date', () => {
-      const result = formatDateTimeForMap('invalid-date', 'America/New_York');
-      expect(result).toBe('');
+    it('returns empty string for invalid inputs', () => {
+      expect(formatDateTimeForMap(undefined, 'America/New_York')).toBe('');
+      expect(formatDateTimeForMap('2024-01-15T10:00:00Z', undefined)).toBe('');
+      expect(formatDateTimeForMap('invalid-date', 'America/New_York')).toBe('');
     });
   });
 });

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

@@ -0,0 +1,259 @@
+/**
+ * @file Number Formatting Utility Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/Formatting
+ * @since 1.0.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  formatCurrency,
+  formatNumber,
+  formatPercent,
+  formatCompactNumber,
+  formatFileSize,
+} from './formatting';
+
+describe('Number Formatting Utilities', () => {
+  describe('formatCurrency', () => {
+    it('formats USD currency by default', () => {
+      const result = formatCurrency(1234.56);
+      expect(result).toContain('$');
+      expect(result).toContain('1,234.56');
+    });
+
+    it('formats different currencies', () => {
+      expect(formatCurrency(1234.56, 'EUR')).toContain('€');
+      expect(formatCurrency(1234.56, 'GBP')).toContain('£');
+      expect(formatCurrency(1234.56, 'JPY')).toContain('¥');
+    });
+
+    it('formats with different locales', () => {
+      const usResult = formatCurrency(1234.56, 'USD', 'en-US');
+      const deResult = formatCurrency(1234.56, 'EUR', 'de-DE');
+      
+      expect(usResult).toContain('$');
+      expect(deResult).toContain('€');
+      // German locale uses different number formatting
+      expect(deResult).not.toBe(usResult);
+    });
+
+    it('handles zero', () => {
+      const result = formatCurrency(0);
+      expect(result).toContain('0');
+    });
+
+    it('handles negative numbers', () => {
+      const result = formatCurrency(-1234.56);
+      expect(result).toContain('-');
+    });
+
+    it('handles very large numbers', () => {
+      const result = formatCurrency(1000000);
+      expect(result).toContain('1,000,000');
+    });
+
+    it('handles very small numbers', () => {
+      const result = formatCurrency(0.01);
+      expect(result).toContain('0.01');
+    });
+
+    it('handles decimal precision correctly', () => {
+      const result = formatCurrency(1234.567);
+      // Currency formatting may round, so just check it contains the main number
+      expect(result).toContain('1,234');
+    });
+  });
+
+  describe('formatNumber', () => {
+    it('formats numbers with default options', () => {
+      const result = formatNumber(1234.56);
+      expect(result).toBe('1,234.56');
+    });
+
+    it('formats with custom decimal places', () => {
+      expect(formatNumber(1234.567, { minimumFractionDigits: 2, maximumFractionDigits: 2 })).toBe('1,234.57');
+      expect(formatNumber(1234.5, { minimumFractionDigits: 2, maximumFractionDigits: 2 })).toBe('1,234.50');
+    });
+
+    it('formats with no decimal places', () => {
+      const result = formatNumber(1234.56, { maximumFractionDigits: 0 });
+      expect(result).toBe('1,235');
+    });
+
+    it('formats with different locales', () => {
+      const usResult = formatNumber(1234.56, {}, 'en-US');
+      const deResult = formatNumber(1234.56, {}, 'de-DE');
+      
+      // German uses comma as decimal separator
+      expect(usResult).toContain('.');
+      expect(deResult).toContain(',');
+    });
+
+    it('handles zero', () => {
+      expect(formatNumber(0)).toBe('0');
+    });
+
+    it('handles negative numbers', () => {
+      expect(formatNumber(-1234.56)).toBe('-1,234.56');
+    });
+
+    it('formats with grouping', () => {
+      const result = formatNumber(1000000);
+      expect(result).toContain(',');
+    });
+
+    it('formats without grouping when disabled', () => {
+      const result = formatNumber(1000000, { useGrouping: false });
+      expect(result).toBe('1000000');
+    });
+  });
+
+  describe('formatPercent', () => {
+    it('formats percentage with default decimals', () => {
+      const result = formatPercent(0.5);
+      expect(result).toContain('%');
+      expect(result).toContain('0.5');
+    });
+
+    it('formats percentage with custom decimals', () => {
+      const result = formatPercent(0.8123, 'en-US', { decimals: 2 });
+      expect(result).toContain('0.81');
+    });
+
+    it('preserves decimal places when preserveDecimals is true', () => {
+      const result = formatPercent(0.8123, 'en-US', { preserveDecimals: true });
+      expect(result).toContain('0.8123');
+    });
+
+    it('limits decimal places with maxDecimals', () => {
+      const result = formatPercent(0.8123456789, 'en-US', { preserveDecimals: true, maxDecimals: 2 });
+      expect(result).toContain('0.81');
+    });
+
+    it('handles zero', () => {
+      const result = formatPercent(0);
+      expect(result).toContain('0');
+      expect(result).toContain('%');
+    });
+
+    it('handles negative percentages', () => {
+      const result = formatPercent(-0.5);
+      expect(result).toContain('-');
+    });
+
+    it('handles whole number percentages', () => {
+      const result = formatPercent(1.0, 'en-US', { preserveDecimals: true });
+      expect(result).toContain('1');
+    });
+
+    it('handles very small percentages', () => {
+      const result = formatPercent(0.001, 'en-US', { preserveDecimals: true });
+      expect(result).toContain('0.001');
+    });
+
+    it('handles very large percentages', () => {
+      const result = formatPercent(100.0);
+      expect(result).toContain('100');
+    });
+  });
+
+  describe('formatCompactNumber', () => {
+    it('formats thousands with K', () => {
+      const result = formatCompactNumber(1000);
+      expect(result).toMatch(/1K/i);
+    });
+
+    it('formats millions with M', () => {
+      const result = formatCompactNumber(1000000);
+      expect(result).toMatch(/1M/i);
+    });
+
+    it('formats billions with B', () => {
+      const result = formatCompactNumber(1000000000);
+      expect(result).toMatch(/1B/i);
+    });
+
+    it('handles zero', () => {
+      const result = formatCompactNumber(0);
+      expect(result).toBe('0');
+    });
+
+    it('handles numbers less than 1000', () => {
+      const result = formatCompactNumber(500);
+      expect(result).toBe('500');
+    });
+
+    it('formats with different locales', () => {
+      const usResult = formatCompactNumber(1000, 'en-US');
+      const deResult = formatCompactNumber(1000, 'de-DE');
+      
+      // Both should format, but may have different representations
+      expect(usResult.length).toBeGreaterThan(0);
+      expect(deResult.length).toBeGreaterThan(0);
+    });
+
+    it('handles very large numbers', () => {
+      const result = formatCompactNumber(1000000000000);
+      expect(result.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('formatFileSize', () => {
+    it('formats bytes correctly', () => {
+      expect(formatFileSize(0)).toBe('0 Bytes');
+      expect(formatFileSize(1)).toContain('Bytes');
+      expect(formatFileSize(512)).toContain('Bytes');
+    });
+
+    it('formats kilobytes correctly', () => {
+      const result = formatFileSize(1024);
+      expect(result).toContain('KB');
+      expect(result).toContain('1');
+    });
+
+    it('formats megabytes correctly', () => {
+      const result = formatFileSize(1024 * 1024);
+      expect(result).toContain('MB');
+      expect(result).toContain('1');
+    });
+
+    it('formats gigabytes correctly', () => {
+      const result = formatFileSize(1024 * 1024 * 1024);
+      expect(result).toContain('GB');
+      expect(result).toContain('1');
+    });
+
+    it('formats terabytes correctly', () => {
+      const result = formatFileSize(1024 * 1024 * 1024 * 1024);
+      expect(result).toContain('TB');
+      expect(result).toContain('1');
+    });
+
+    it('formats petabytes correctly', () => {
+      const result = formatFileSize(1024 * 1024 * 1024 * 1024 * 1024);
+      expect(result).toContain('PB');
+      expect(result).toContain('1');
+    });
+
+    it('formats fractional sizes correctly', () => {
+      const result = formatFileSize(1536); // 1.5 KB
+      expect(result).toContain('1.5');
+      expect(result).toContain('KB');
+    });
+
+    it('rounds to 2 decimal places', () => {
+      const result = formatFileSize(1537);
+      // formatFileSize uses toFixed(2) which may show 1.5 or 1.50 depending on implementation
+      expect(result).toMatch(/\d+\.\d{1,2}/);
+      expect(result).toContain('KB');
+    });
+
+    it('handles edge cases at unit boundaries', () => {
+      // 1023 bytes is still in Bytes range (log(1023) < log(1024))
+      expect(formatFileSize(1023)).toContain('Bytes');
+      expect(formatFileSize(1024)).toContain('KB');
+      expect(formatFileSize(1025)).toContain('KB');
+    });
+  });
+});

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

@@ -7,13 +7,10 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { formatTime } from './formatting';
 
 describe('formatTime 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,95 +19,63 @@ describe('formatTime Utility', () => {
   });
 
   describe('Date Object Input', () => {
-    it('formats a Date object correctly', () => {
-      const date = new Date('2024-01-15T14:30:00.000Z');
-      const result = formatTime(date);
-      
-      // Should be in HH:mm format (24-hour)
-      expect(result).toMatch(/^\d{2}:\d{2}$/);
-    });
-
-    it('formats different times correctly', () => {
+    it('formats times correctly in 24-hour format', () => {
       const dates = [
-        new Date('2024-01-15T00:00:00.000Z'),
-        new Date('2024-01-15T12:00:00.000Z'),
+        new Date('2024-01-15T00:00:00.000Z'), // midnight
+        new Date('2024-01-15T12:00:00.000Z'), // noon
+        new Date('2024-01-15T14:30:00.000Z'),
         new Date('2024-01-15T23:59:00.000Z')
       ];
       
       dates.forEach(date => {
         const result = formatTime(date);
         expect(result).toMatch(/^\d{2}:\d{2}$/);
+        expect(result).not.toMatch(/AM|PM/i);
       });
     });
-
-    it('formats midnight correctly', () => {
-      const date = new Date('2024-01-15T00:00:00.000Z');
-      const result = formatTime(date);
-      expect(result).toMatch(/^\d{2}:\d{2}$/);
-    });
-
-    it('formats noon correctly', () => {
-      const date = new Date('2024-01-15T12:00:00.000Z');
-      const result = formatTime(date);
-      expect(result).toMatch(/^\d{2}:\d{2}$/);
-    });
   });
 
   describe('String Input', () => {
-    it('formats ISO datetime strings correctly', () => {
-      const result = formatTime('2024-01-15T14:30:00.000Z');
-      expect(result).toMatch(/^\d{2}:\d{2}$/);
-    });
-
-    it('formats ISO date strings correctly', () => {
-      const result = formatTime('2024-01-15');
-      expect(result).toMatch(/^\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 = formatTime(dateString);
+        expect(result).toMatch(/^\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 = formatTime(timestamp);
-      expect(result).toMatch(/^\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 = formatTime(unixTimestamp * 1000); // Convert back to milliseconds
-      expect(result).toMatch(/^\d{2}:\d{2}$/);
+      const unixTimestamp = Math.floor(timestamp / 1000) * 1000;
+      
+      expect(formatTime(timestamp)).toMatch(/^\d{2}:\d{2}$/);
+      expect(formatTime(unixTimestamp)).toMatch(/^\d{2}:\d{2}$/);
     });
   });
 
   describe('Edge Cases', () => {
-    it('handles invalid date strings gracefully', () => {
-      const invalidDate = new Date('invalid-date');
-      const result = formatTime(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 = formatTime('');
-      expect(typeof result).toBe('string');
-    });
-
-    it('handles zero', () => {
-      const result = formatTime(0);
-      expect(typeof result).toBe('string');
+      invalidInputs.forEach(input => {
+        const result = formatTime(input as any);
+        expect(typeof result).toBe('string');
+      });
     });
   });
 
   describe('Format Consistency', () => {
-    it('returns consistent format for same time', () => {
-      const date = new Date('2024-01-15T14:30:00.000Z');
-      const result1 = formatTime(date);
-      const result2 = formatTime(date);
-      
-      expect(result1).toBe(result2);
-    });
-
     it('returns consistent format across different input types for same time', () => {
       const date = new Date('2024-01-15T14:30:00.000Z');
       const dateString = '2024-01-15T14:30:00.000Z';
@@ -122,65 +87,8 @@ describe('formatTime Utility', () => {
       
       expect(result1).toBe(result2);
       expect(result2).toBe(result3);
-    });
-  });
-
-  describe('24-Hour Format', () => {
-    it('uses 24-hour format (no AM/PM)', () => {
-      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 = formatTime(morning);
-      const afternoonResult = formatTime(afternoon);
-      const eveningResult = formatTime(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);
-    });
-
-    it('formats times correctly in 24-hour format', () => {
-      const date = new Date('2024-01-15T14:30:00.000Z');
-      const result = formatTime(date);
-      
-      // Should be in HH:mm format
-      expect(result).toMatch(/^\d{2}:\d{2}$/);
-    });
-  });
-
-  describe('Performance', () => {
-    it('handles many calls efficiently', () => {
-      const date = new Date('2024-01-15T14:30:00.000Z');
-      
-      // Call formatTime many times
-      const start = performance.now();
-      for (let i = 0; i < 1000; i++) {
-        formatTime(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(() => formatTime(date)).not.toThrow();
-    });
-
-    it('handles string inputs', () => {
-      const dateString = '2024-01-15T14:30:00.000Z';
-      expect(() => formatTime(dateString)).not.toThrow();
-    });
-
-    it('handles number inputs', () => {
-      const timestamp = new Date('2024-01-15T14:30:00.000Z').getTime();
-      expect(() => formatTime(timestamp)).not.toThrow();
+      expect(result1).toMatch(/^\d{2}:\d{2}$/);
+      expect(result1).not.toMatch(/AM|PM/i);
     });
   });
 });

package/src/utils/formatting/formatting.ts

@@ -3,7 +3,7 @@
  */
 
 import { parseISO, isValid } from 'date-fns';
-import { formatInTimeZone, getTimezoneAbbreviation } from '../timezone';
+import { formatInTimeZone, getTimezoneAbbreviation } from '../timezone/timezone';
 
 /**
  * Format a date as a readable string in "dd mmm yyyy" format (e.g., "15 Jun 2024")