@getmicdrop/svelte-components 5.3.10 → 5.3.13

package/dist/constants/validation.spec.js

@@ -1,64 +1,64 @@
-import { describe, it, expect } from 'vitest';
-import {
-  MIN_EVENT_DURATION_MINS,
-  MAX_EVENT_DURATION_MINS,
-  DEFAULT_EVENT_DURATION_MINS,
-  DEFAULT_DOORS_BEFORE_START_MINS,
-  MAX_TICKETS_PER_ORDER,
-  MIN_TICKETS_PER_ORDER,
-  MAX_PERCENTAGE_DISCOUNT,
-  ErrorCodes,
-} from './validation.js';
-
-describe('validation constants', () => {
-  describe('event time constants', () => {
-    it('exports MIN_EVENT_DURATION_MINS as 15', () => {
-      expect(MIN_EVENT_DURATION_MINS).toBe(15);
-    });
-
-    it('exports MAX_EVENT_DURATION_MINS as 1440 (24 hours)', () => {
-      expect(MAX_EVENT_DURATION_MINS).toBe(1440);
-    });
-
-    it('exports DEFAULT_EVENT_DURATION_MINS as 90', () => {
-      expect(DEFAULT_EVENT_DURATION_MINS).toBe(90);
-    });
-
-    it('exports DEFAULT_DOORS_BEFORE_START_MINS as 30', () => {
-      expect(DEFAULT_DOORS_BEFORE_START_MINS).toBe(30);
-    });
-  });
-
-  describe('ticket constants', () => {
-    it('exports MAX_TICKETS_PER_ORDER as 100', () => {
-      expect(MAX_TICKETS_PER_ORDER).toBe(100);
-    });
-
-    it('exports MIN_TICKETS_PER_ORDER as 0', () => {
-      expect(MIN_TICKETS_PER_ORDER).toBe(0);
-    });
-  });
-
-  describe('promo code constants', () => {
-    it('exports MAX_PERCENTAGE_DISCOUNT as 100', () => {
-      expect(MAX_PERCENTAGE_DISCOUNT).toBe(100);
-    });
-  });
-
-  describe('error codes', () => {
-    it('exports ErrorCodes object with event errors', () => {
-      expect(ErrorCodes.EVENT_DURATION_TOO_SHORT).toBe('EVENT_DURATION_TOO_SHORT');
-      expect(ErrorCodes.EVENT_END_BEFORE_START).toBe('EVENT_END_BEFORE_START');
-    });
-
-    it('exports ErrorCodes object with ticket errors', () => {
-      expect(ErrorCodes.PRICE_REQUIRED).toBe('PRICE_REQUIRED');
-      expect(ErrorCodes.QUANTITY_REQUIRED).toBe('QUANTITY_REQUIRED');
-    });
-
-    it('exports ErrorCodes object with promo errors', () => {
-      expect(ErrorCodes.PROMO_NAME_REQUIRED).toBe('PROMO_NAME_REQUIRED');
-      expect(ErrorCodes.PROMO_PERCENT_EXCEEDS_100).toBe('PROMO_PERCENT_EXCEEDS_100');
-    });
-  });
-});
+import { describe, it, expect } from 'vitest';
+import {
+  MIN_EVENT_DURATION_MINS,
+  MAX_EVENT_DURATION_MINS,
+  DEFAULT_EVENT_DURATION_MINS,
+  DEFAULT_DOORS_BEFORE_START_MINS,
+  MAX_TICKETS_PER_ORDER,
+  MIN_TICKETS_PER_ORDER,
+  MAX_PERCENTAGE_DISCOUNT,
+  ErrorCodes,
+} from './validation.js';
+
+describe('validation constants', () => {
+  describe('event time constants', () => {
+    it('exports MIN_EVENT_DURATION_MINS as 15', () => {
+      expect(MIN_EVENT_DURATION_MINS).toBe(15);
+    });
+
+    it('exports MAX_EVENT_DURATION_MINS as 1440 (24 hours)', () => {
+      expect(MAX_EVENT_DURATION_MINS).toBe(1440);
+    });
+
+    it('exports DEFAULT_EVENT_DURATION_MINS as 90', () => {
+      expect(DEFAULT_EVENT_DURATION_MINS).toBe(90);
+    });
+
+    it('exports DEFAULT_DOORS_BEFORE_START_MINS as 30', () => {
+      expect(DEFAULT_DOORS_BEFORE_START_MINS).toBe(30);
+    });
+  });
+
+  describe('ticket constants', () => {
+    it('exports MAX_TICKETS_PER_ORDER as 100', () => {
+      expect(MAX_TICKETS_PER_ORDER).toBe(100);
+    });
+
+    it('exports MIN_TICKETS_PER_ORDER as 0', () => {
+      expect(MIN_TICKETS_PER_ORDER).toBe(0);
+    });
+  });
+
+  describe('promo code constants', () => {
+    it('exports MAX_PERCENTAGE_DISCOUNT as 100', () => {
+      expect(MAX_PERCENTAGE_DISCOUNT).toBe(100);
+    });
+  });
+
+  describe('error codes', () => {
+    it('exports ErrorCodes object with event errors', () => {
+      expect(ErrorCodes.EVENT_DURATION_TOO_SHORT).toBe('EVENT_DURATION_TOO_SHORT');
+      expect(ErrorCodes.EVENT_END_BEFORE_START).toBe('EVENT_END_BEFORE_START');
+    });
+
+    it('exports ErrorCodes object with ticket errors', () => {
+      expect(ErrorCodes.PRICE_REQUIRED).toBe('PRICE_REQUIRED');
+      expect(ErrorCodes.QUANTITY_REQUIRED).toBe('QUANTITY_REQUIRED');
+    });
+
+    it('exports ErrorCodes object with promo errors', () => {
+      expect(ErrorCodes.PROMO_NAME_REQUIRED).toBe('PROMO_NAME_REQUIRED');
+      expect(ErrorCodes.PROMO_PERCENT_EXCEEDS_100).toBe('PROMO_PERCENT_EXCEEDS_100');
+    });
+  });
+});

package/dist/datetime/__tests__/format.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=format.test.d.ts.map

package/dist/datetime/__tests__/format.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.test.d.ts","sourceRoot":"","sources":["../../../src/lib/datetime/__tests__/format.test.ts"],"names":[],"mappings":""}

package/dist/datetime/__tests__/format.test.js

@@ -0,0 +1,268 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { formatDateRange, formatDayOfWeek, formatEventDate, formatEventDateTime, formatEventTime, formatMonth, formatNotificationTime, formatRelativeTime, formatTimeRange, getDateInTimezone, getDateParts, getHourInTimezone, } from '../format';
+import { DateTimeError, DateTimeErrorCode } from '../types';
+describe('format utilities', () => {
+    describe('formatEventTime', () => {
+        it('formats time in specified timezone', () => {
+            // 3 AM UTC = 7 PM previous day in LA (UTC-8 in winter)
+            const utc = '2023-12-25T03:00:00Z';
+            expect(formatEventTime(utc, 'America/Los_Angeles')).toBe('7:00 PM');
+        });
+        it('handles midnight correctly', () => {
+            // 8 AM UTC = midnight in LA
+            const utc = '2023-12-25T08:00:00Z';
+            expect(formatEventTime(utc, 'America/Los_Angeles')).toBe('12:00 AM');
+        });
+        it('handles noon correctly', () => {
+            // 8 PM UTC = noon in LA
+            const utc = '2023-12-25T20:00:00Z';
+            expect(formatEventTime(utc, 'America/Los_Angeles')).toBe('12:00 PM');
+        });
+        it('works with different timezones', () => {
+            const utc = '2023-12-25T17:00:00Z';
+            // 5 PM UTC = different times in different zones
+            expect(formatEventTime(utc, 'America/New_York')).toBe('12:00 PM');
+            expect(formatEventTime(utc, 'Europe/London')).toBe('5:00 PM');
+            expect(formatEventTime(utc, 'Asia/Tokyo')).toBe('2:00 AM'); // Next day
+        });
+        it('formats with seconds when option is set', () => {
+            const utc = '2023-12-25T17:30:45Z';
+            expect(formatEventTime(utc, 'America/Los_Angeles', { includeSeconds: true })).toBe('9:30:45 AM');
+        });
+        it('throws on invalid timezone', () => {
+            expect(() => formatEventTime('2023-12-25T12:00:00Z', 'Invalid/Zone')).toThrow(DateTimeError);
+        });
+        it('throws on invalid ISO string', () => {
+            expect(() => formatEventTime('not-a-date', 'America/Los_Angeles')).toThrow(DateTimeError);
+        });
+        it('throws on empty ISO string', () => {
+            expect(() => formatEventTime('', 'America/Los_Angeles')).toThrow(DateTimeError);
+        });
+    });
+    describe('formatEventDate', () => {
+        it('formats date in specified timezone', () => {
+            // 3 AM UTC on Dec 25 = still Dec 24 at 7 PM in LA
+            const utc = '2023-12-25T03:00:00Z';
+            expect(formatEventDate(utc, 'America/Los_Angeles')).toBe('Dec 24, 2023');
+        });
+        it('handles timezone boundary correctly', () => {
+            // 7 AM UTC on Dec 25 = 11 PM Dec 24 in LA
+            const utc = '2023-12-25T07:00:00Z';
+            expect(formatEventDate(utc, 'America/Los_Angeles')).toBe('Dec 24, 2023');
+        });
+        it('formats date without year when option is set', () => {
+            const utc = '2023-12-25T20:00:00Z';
+            expect(formatEventDate(utc, 'America/Los_Angeles', { includeYear: false })).toBe('Dec 25');
+        });
+        it('throws on invalid timezone', () => {
+            expect(() => formatEventDate('2023-12-25T12:00:00Z', 'Invalid/Zone')).toThrow(DateTimeError);
+        });
+    });
+    describe('formatEventDateTime', () => {
+        it('formats full datetime', () => {
+            const utc = '2023-12-26T03:00:00Z'; // 7 PM Dec 25 in LA
+            expect(formatEventDateTime(utc, 'America/Los_Angeles')).toBe('Dec 25, 2023 at 7:00 PM');
+        });
+        it('handles different timezones', () => {
+            const utc = '2023-12-25T17:00:00Z';
+            expect(formatEventDateTime(utc, 'America/New_York')).toBe('Dec 25, 2023 at 12:00 PM');
+        });
+        it('throws on invalid inputs', () => {
+            expect(() => formatEventDateTime('invalid', 'America/Los_Angeles')).toThrow();
+            expect(() => formatEventDateTime('2023-12-25T12:00:00Z', 'Invalid/Zone')).toThrow();
+        });
+    });
+    describe('formatTimeRange', () => {
+        it('formats time range on same day', () => {
+            const start = '2023-12-25T03:00:00Z';
+            const end = '2023-12-25T06:00:00Z';
+            expect(formatTimeRange(start, end, 'America/Los_Angeles')).toBe('7:00 PM - 10:00 PM');
+        });
+        it('handles ranges spanning midnight', () => {
+            // 10 PM Dec 24 to 2 AM Dec 25 in LA
+            const start = '2023-12-25T06:00:00Z';
+            const end = '2023-12-25T10:00:00Z';
+            expect(formatTimeRange(start, end, 'America/Los_Angeles')).toBe('10:00 PM - 2:00 AM');
+        });
+        it('handles identical start and end times', () => {
+            const time = '2023-12-25T03:00:00Z';
+            expect(formatTimeRange(time, time, 'America/Los_Angeles')).toBe('7:00 PM - 7:00 PM');
+        });
+        it('throws on invalid inputs', () => {
+            expect(() => formatTimeRange('invalid', '2023-12-25T06:00:00Z', 'America/Los_Angeles')).toThrow();
+        });
+    });
+    describe('formatDateRange', () => {
+        it('formats same day as single date', () => {
+            // 8 AM UTC = midnight in LA, 8 PM UTC = noon in LA (same day Dec 20)
+            const start = '2023-12-20T08:00:00Z';
+            const end = '2023-12-20T20:00:00Z';
+            expect(formatDateRange(start, end, 'America/Los_Angeles')).toBe('Dec 20, 2023');
+        });
+        it('formats same month range', () => {
+            // 8 AM UTC = midnight in LA for each day
+            const start = '2023-12-20T08:00:00Z';
+            const end = '2023-12-23T08:00:00Z';
+            expect(formatDateRange(start, end, 'America/Los_Angeles')).toBe('Dec 20 - 23, 2023');
+        });
+        it('formats different month same year range', () => {
+            const start = '2023-12-28T08:00:00Z';
+            const end = '2024-01-05T08:00:00Z';
+            expect(formatDateRange(start, end, 'America/Los_Angeles')).toBe('Dec 28, 2023 - Jan 5, 2024');
+        });
+        it('formats different year range', () => {
+            const start = '2023-12-20T08:00:00Z';
+            const end = '2024-01-20T08:00:00Z';
+            expect(formatDateRange(start, end, 'America/Los_Angeles')).toBe('Dec 20, 2023 - Jan 20, 2024');
+        });
+        it('handles timezone boundary correctly', () => {
+            // 3 AM UTC on Dec 25 = 7 PM Dec 24 in LA
+            const start = '2023-12-25T03:00:00Z';
+            const end = '2023-12-26T03:00:00Z';
+            expect(formatDateRange(start, end, 'America/Los_Angeles')).toBe('Dec 24 - 25, 2023');
+        });
+    });
+    describe('formatRelativeTime', () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date('2023-12-25T12:00:00Z'));
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+        it('shows "just now" for recent times', () => {
+            const now = new Date().toISOString();
+            expect(formatRelativeTime(now, 'America/Los_Angeles')).toBe('just now');
+        });
+        it('shows minutes ago', () => {
+            const thirtyMinutesAgo = new Date(Date.now() - 30 * 60 * 1000).toISOString();
+            expect(formatRelativeTime(thirtyMinutesAgo, 'America/Los_Angeles')).toBe('30 minutes ago');
+        });
+        it('shows singular minute', () => {
+            const oneMinuteAgo = new Date(Date.now() - 1 * 60 * 1000).toISOString();
+            expect(formatRelativeTime(oneMinuteAgo, 'America/Los_Angeles')).toBe('1 minute ago');
+        });
+        it('shows hours ago', () => {
+            const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
+            expect(formatRelativeTime(twoHoursAgo, 'America/Los_Angeles')).toBe('2 hours ago');
+        });
+        it('shows days ago', () => {
+            const threeDaysAgo = new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString();
+            expect(formatRelativeTime(threeDaysAgo, 'America/Los_Angeles')).toBe('3 days ago');
+        });
+        it('shows future times correctly', () => {
+            const twoHoursFromNow = new Date(Date.now() + 2 * 60 * 60 * 1000).toISOString();
+            expect(formatRelativeTime(twoHoursFromNow, 'America/Los_Angeles')).toBe('in 2 hours');
+        });
+        it('shows singular future hour', () => {
+            const oneHourFromNow = new Date(Date.now() + 1 * 60 * 60 * 1000).toISOString();
+            expect(formatRelativeTime(oneHourFromNow, 'America/Los_Angeles')).toBe('in 1 hour');
+        });
+        it('shows weeks', () => {
+            const twoWeeksAgo = new Date(Date.now() - 14 * 24 * 60 * 60 * 1000).toISOString();
+            expect(formatRelativeTime(twoWeeksAgo, 'America/Los_Angeles')).toBe('2 weeks ago');
+        });
+        it('shows date for old times', () => {
+            const longAgo = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000).toISOString();
+            expect(formatRelativeTime(longAgo, 'America/Los_Angeles')).toMatch(/Oct \d+, 2023/);
+        });
+        it('throws on invalid timezone', () => {
+            expect(() => formatRelativeTime('2023-12-25T12:00:00Z', 'Invalid/Zone')).toThrow();
+        });
+    });
+    describe('getDateParts', () => {
+        it('extracts date parts correctly', () => {
+            const parts = getDateParts('2023-12-25T20:00:00Z', 'America/Los_Angeles');
+            expect(parts).toEqual({
+                day: 'Mon',
+                month: 'Dec',
+                date: 25,
+                year: 2023,
+            });
+        });
+        it('handles timezone boundary', () => {
+            // 3 AM UTC on Dec 25 = 7 PM Dec 24 in LA
+            const parts = getDateParts('2023-12-25T03:00:00Z', 'America/Los_Angeles');
+            expect(parts.date).toBe(24);
+            expect(parts.month).toBe('Dec');
+            expect(parts.day).toBe('Sun');
+        });
+        it('handles different timezones', () => {
+            const utc = '2023-12-25T12:00:00Z';
+            const laParts = getDateParts(utc, 'America/Los_Angeles');
+            expect(laParts.date).toBe(25);
+            const tokyoParts = getDateParts(utc, 'Asia/Tokyo');
+            expect(tokyoParts.date).toBe(25); // 9 PM on Dec 25 in Tokyo
+        });
+        it('throws on invalid inputs', () => {
+            expect(() => getDateParts('invalid', 'America/Los_Angeles')).toThrow();
+            expect(() => getDateParts('2023-12-25T12:00:00Z', 'Invalid/Zone')).toThrow();
+        });
+    });
+    describe('formatNotificationTime', () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date('2023-12-25T12:00:00Z'));
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+        it('shows relative time for recent notifications', () => {
+            const oneHourAgo = new Date(Date.now() - 1 * 60 * 60 * 1000).toISOString();
+            expect(formatNotificationTime(oneHourAgo, 'America/Los_Angeles')).toBe('1 hour ago');
+        });
+        it('shows day of week for recent days', () => {
+            const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000).toISOString();
+            const result = formatNotificationTime(twoDaysAgo, 'America/Los_Angeles');
+            expect(result).toMatch(/Saturday at/);
+        });
+        it('shows full date for older notifications', () => {
+            const twoWeeksAgo = new Date(Date.now() - 14 * 24 * 60 * 60 * 1000).toISOString();
+            const result = formatNotificationTime(twoWeeksAgo, 'America/Los_Angeles');
+            expect(result).toMatch(/Dec \d+, 2023 at/);
+        });
+    });
+    describe('formatDayOfWeek', () => {
+        it('returns short day name by default', () => {
+            const utc = '2023-12-25T20:00:00Z';
+            expect(formatDayOfWeek(utc, 'America/Los_Angeles')).toBe('Mon');
+        });
+        it('returns full day name when short=false', () => {
+            const utc = '2023-12-25T20:00:00Z';
+            expect(formatDayOfWeek(utc, 'America/Los_Angeles', false)).toBe('Monday');
+        });
+    });
+    describe('formatMonth', () => {
+        it('returns short month name by default', () => {
+            const utc = '2023-12-25T20:00:00Z';
+            expect(formatMonth(utc, 'America/Los_Angeles')).toBe('Dec');
+        });
+        it('returns full month name when short=false', () => {
+            const utc = '2023-12-25T20:00:00Z';
+            expect(formatMonth(utc, 'America/Los_Angeles', false)).toBe('December');
+        });
+    });
+    describe('getHourInTimezone', () => {
+        it('returns correct hour', () => {
+            // 8 PM UTC = noon in LA
+            const utc = '2023-12-25T20:00:00Z';
+            expect(getHourInTimezone(utc, 'America/Los_Angeles')).toBe(12);
+        });
+        it('handles midnight', () => {
+            // 8 AM UTC = midnight in LA
+            const utc = '2023-12-25T08:00:00Z';
+            expect(getHourInTimezone(utc, 'America/Los_Angeles')).toBe(0);
+        });
+    });
+    describe('getDateInTimezone', () => {
+        it('returns date string in YYYY-MM-DD format', () => {
+            const utc = '2023-12-25T20:00:00Z';
+            expect(getDateInTimezone(utc, 'America/Los_Angeles')).toBe('2023-12-25');
+        });
+        it('handles timezone boundary', () => {
+            // 3 AM UTC on Dec 25 = 7 PM Dec 24 in LA
+            const utc = '2023-12-25T03:00:00Z';
+            expect(getDateInTimezone(utc, 'America/Los_Angeles')).toBe('2023-12-24');
+        });
+    });
+});

package/dist/datetime/__tests__/integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=integration.test.d.ts.map

package/dist/datetime/__tests__/integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.test.d.ts","sourceRoot":"","sources":["../../../src/lib/datetime/__tests__/integration.test.ts"],"names":[],"mappings":""}

package/dist/datetime/__tests__/integration.test.js

@@ -0,0 +1,243 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as datetime from '../index';
+describe('datetime module integration', () => {
+    describe('full workflow tests', () => {
+        it('round-trips local time through UTC and back', () => {
+            const localInput = '2023-12-25T19:00:00';
+            const timezone = 'America/Los_Angeles';
+            const utc = datetime.parseLocalToUTC(localInput, timezone);
+            const localOutput = datetime.parseUTCToLocal(utc, timezone);
+            expect(localOutput).toBe(localInput);
+        });
+        it('formats event correctly end-to-end', () => {
+            const venue = { timezone: 'America/Los_Angeles' };
+            const eventStart = '2023-12-26T03:00:00Z'; // 7 PM Dec 25 in LA
+            const eventEnd = '2023-12-26T06:00:00Z'; // 10 PM Dec 25 in LA
+            const tz = datetime.getVenueTimezone(venue);
+            expect(datetime.formatEventDate(eventStart, tz)).toBe('Dec 25, 2023');
+            expect(datetime.formatTimeRange(eventStart, eventEnd, tz)).toBe('7:00 PM - 10:00 PM');
+            expect(datetime.formatEventDateTime(eventStart, tz)).toBe('Dec 25, 2023 at 7:00 PM');
+        });
+        it('handles all major US timezones', () => {
+            const utc = '2023-12-25T20:00:00Z';
+            expect(datetime.formatEventTime(utc, 'America/Los_Angeles')).toBe('12:00 PM');
+            expect(datetime.formatEventTime(utc, 'America/Denver')).toBe('1:00 PM');
+            expect(datetime.formatEventTime(utc, 'America/Chicago')).toBe('2:00 PM');
+            expect(datetime.formatEventTime(utc, 'America/New_York')).toBe('3:00 PM');
+        });
+        it('handles Arizona (no DST) correctly', () => {
+            const winterUtc = '2023-01-15T20:00:00Z';
+            const summerUtc = '2023-07-15T20:00:00Z';
+            // Arizona should have same offset year-round
+            expect(datetime.formatEventTime(winterUtc, 'America/Phoenix')).toBe('1:00 PM');
+            expect(datetime.formatEventTime(summerUtc, 'America/Phoenix')).toBe('1:00 PM');
+            // LA changes with DST
+            expect(datetime.formatEventTime(winterUtc, 'America/Los_Angeles')).toBe('12:00 PM');
+            expect(datetime.formatEventTime(summerUtc, 'America/Los_Angeles')).toBe('1:00 PM');
+        });
+    });
+    describe('event creation workflow', () => {
+        it('creates event with correct UTC times from form inputs', () => {
+            const venue = {
+                name: 'Jetpack Comedy @ Bar Lubitsch',
+                timezone: 'America/Los_Angeles',
+            };
+            // User enters local time in form
+            const eventDate = '2023-12-25';
+            const startTime = '20:00'; // 8 PM
+            const endTime = '22:30'; // 10:30 PM
+            const tz = datetime.getVenueTimezone(venue);
+            // Convert to UTC for API
+            const startUtc = datetime.combineDateAndTime(eventDate, startTime, tz);
+            const endUtc = datetime.combineDateAndTime(eventDate, endTime, tz);
+            // Verify UTC values
+            expect(startUtc).toBe('2023-12-26T04:00:00.000Z');
+            expect(endUtc).toBe('2023-12-26T06:30:00.000Z');
+            // Verify display formatting
+            expect(datetime.formatEventDateTime(startUtc, tz)).toBe('Dec 25, 2023 at 8:00 PM');
+            expect(datetime.formatTimeRange(startUtc, endUtc, tz)).toBe('8:00 PM - 10:30 PM');
+        });
+        it('handles overnight events correctly', () => {
+            const tz = 'America/Los_Angeles';
+            // Event from 10 PM to 2 AM
+            const startUtc = datetime.combineDateAndTime('2023-12-25', '22:00', tz);
+            const endUtc = datetime.combineDateAndTime('2023-12-26', '02:00', tz);
+            expect(datetime.formatTimeRange(startUtc, endUtc, tz)).toBe('10:00 PM - 2:00 AM');
+            expect(datetime.formatEventDate(startUtc, tz)).toBe('Dec 25, 2023');
+            expect(datetime.formatEventDate(endUtc, tz)).toBe('Dec 26, 2023');
+        });
+    });
+    describe('public calendar display workflow', () => {
+        it('displays events in venue timezone regardless of user timezone', () => {
+            const venue = {
+                name: 'Dallas Comedy Club',
+                timezone: 'America/Chicago', // Central Time
+            };
+            const eventUtc = '2023-12-26T01:00:00Z'; // 7 PM Dec 25 in Chicago
+            // User might be viewing from anywhere, but we show venue time
+            const venueTz = datetime.getVenueTimezone(venue);
+            expect(datetime.formatEventTime(eventUtc, venueTz)).toBe('7:00 PM');
+            expect(datetime.formatEventDate(eventUtc, venueTz)).toBe('Dec 25, 2023');
+            // Get date parts for calendar display
+            const parts = datetime.getDateParts(eventUtc, venueTz);
+            expect(parts).toEqual({
+                day: 'Mon',
+                month: 'Dec',
+                date: 25,
+                year: 2023,
+            });
+        });
+        it('groups events by local date correctly', () => {
+            const tz = 'America/Los_Angeles';
+            // These events span the date boundary in LA but are same day in UTC
+            const event1 = '2023-12-25T06:00:00Z'; // 10 PM Dec 24 in LA
+            const event2 = '2023-12-25T10:00:00Z'; // 2 AM Dec 25 in LA
+            expect(datetime.getDateInTimezone(event1, tz)).toBe('2023-12-24');
+            expect(datetime.getDateInTimezone(event2, tz)).toBe('2023-12-25');
+        });
+    });
+    describe('order confirmation workflow', () => {
+        it('formats order confirmation with correct timezone info', () => {
+            const venue = { timezone: 'America/Denver' };
+            const eventStart = '2023-12-26T02:00:00Z'; // 7 PM Dec 25 in Denver
+            const orderCreated = '2023-12-20T15:30:00Z';
+            const venueTz = datetime.getVenueTimezone(venue);
+            // Event info
+            expect(datetime.formatEventDateTime(eventStart, venueTz)).toBe('Dec 25, 2023 at 7:00 PM');
+            // Order timestamp (show in venue timezone for consistency)
+            expect(datetime.formatEventDateTime(orderCreated, venueTz)).toBe('Dec 20, 2023 at 8:30 AM');
+        });
+    });
+    describe('relative time for notifications', () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date('2023-12-25T12:00:00Z'));
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+        it('shows appropriate relative times', () => {
+            const tz = 'America/Los_Angeles';
+            // Just happened
+            const justNow = new Date(Date.now() - 30 * 1000).toISOString();
+            expect(datetime.formatRelativeTime(justNow, tz)).toBe('just now');
+            // Upcoming event
+            const tomorrow = new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString();
+            expect(datetime.formatRelativeTime(tomorrow, tz)).toBe('in 1 day');
+            // Past event
+            const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+            expect(datetime.formatRelativeTime(yesterday, tz)).toBe('1 day ago');
+        });
+    });
+    describe('timezone normalization for legacy data', () => {
+        it('handles legacy timezone abbreviations', () => {
+            const legacyVenue = { timezone: 'PST' };
+            // This would normally throw, but we can normalize first
+            const normalized = datetime.normalizeTimezone(legacyVenue.timezone);
+            expect(normalized).toBe('America/Los_Angeles');
+            // Now we can use it
+            const eventUtc = '2023-12-25T20:00:00Z';
+            expect(datetime.formatEventTime(eventUtc, normalized)).toBe('12:00 PM');
+        });
+    });
+    describe('DST handling', () => {
+        it('correctly handles spring forward', () => {
+            const tz = 'America/Los_Angeles';
+            // March 12, 2023 - DST starts at 2 AM (clocks spring forward to 3 AM)
+            // 10 AM UTC = 2 AM PST (but becomes 3 AM PDT)
+            const dstDay = '2023-03-12T10:00:00Z';
+            expect(datetime.formatEventTime(dstDay, tz)).toBe('3:00 AM');
+            expect(datetime.isDST(tz, new Date(dstDay))).toBe(true);
+        });
+        it('correctly handles fall back', () => {
+            const tz = 'America/Los_Angeles';
+            // November 5, 2023 - DST ends at 2 AM (clocks fall back to 1 AM)
+            // Before the change (still in PDT)
+            const beforeFallback = '2023-11-05T08:00:00Z'; // 1 AM PDT
+            expect(datetime.formatEventTime(beforeFallback, tz)).toBe('1:00 AM');
+            // After the change (now in PST)
+            const afterFallback = '2023-11-05T10:00:00Z'; // 2 AM PST
+            expect(datetime.formatEventTime(afterFallback, tz)).toBe('2:00 AM');
+        });
+    });
+    describe('error handling', () => {
+        it('provides helpful error messages', () => {
+            try {
+                datetime.getVenueTimezone({ name: 'Test Venue' });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(datetime.DateTimeError);
+                expect(e.code).toBe(datetime.DateTimeErrorCode.MISSING_TIMEZONE);
+                expect(e.message).toContain('required');
+            }
+        });
+        it('includes context in error details', () => {
+            try {
+                datetime.formatEventTime('2023-12-25T12:00:00Z', 'Invalid/Zone');
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(datetime.DateTimeError);
+                expect(e.details?.timezone).toBe('Invalid/Zone');
+            }
+        });
+    });
+    describe('constants are exported correctly', () => {
+        it('exports duration constants', () => {
+            expect(datetime.DURATIONS.MINUTE).toBe(60 * 1000);
+            expect(datetime.DURATIONS.HOUR).toBe(60 * 60 * 1000);
+            expect(datetime.DURATIONS.DAY).toBe(24 * 60 * 60 * 1000);
+        });
+        it('exports common US timezones', () => {
+            expect(datetime.COMMON_US_TIMEZONES).toHaveLength(7);
+            expect(datetime.COMMON_US_TIMEZONES[0].id).toBe('America/Los_Angeles');
+        });
+        it('exports event defaults', () => {
+            expect(datetime.EVENT_DEFAULTS.DEFAULT_DURATION_MINUTES).toBe(120);
+            expect(datetime.EVENT_DEFAULTS.MIN_DURATION_MINUTES).toBe(15);
+        });
+    });
+    describe('form handling workflow', () => {
+        it('parses API response for form population', () => {
+            const apiEvent = {
+                startTime: '2023-12-26T03:00:00Z',
+                endTime: '2023-12-26T05:30:00Z',
+                venue: { timezone: 'America/Los_Angeles' },
+            };
+            const tz = datetime.getVenueTimezone(apiEvent.venue);
+            const start = datetime.parseDateTimeFromAPI(apiEvent.startTime, tz);
+            const end = datetime.parseDateTimeFromAPI(apiEvent.endTime, tz);
+            // These values go into form inputs
+            expect(start.date).toBe('2023-12-25');
+            expect(start.time).toBe('19:00');
+            expect(end.date).toBe('2023-12-25');
+            expect(end.time).toBe('21:30');
+        });
+        it('converts form values back to API format', () => {
+            const tz = 'America/Los_Angeles';
+            const formDate = '2023-12-25';
+            const formStartTime = '19:00';
+            const formEndTime = '21:30';
+            const startUtc = datetime.combineDateAndTime(formDate, formStartTime, tz);
+            const endUtc = datetime.combineDateAndTime(formDate, formEndTime, tz);
+            expect(startUtc).toBe('2023-12-26T03:00:00.000Z');
+            expect(endUtc).toBe('2023-12-26T05:30:00.000Z');
+        });
+    });
+    describe('next-day time handling for overnight events', () => {
+        it('handles next-day end times', () => {
+            const tz = 'America/Los_Angeles';
+            // Event starts at 10 PM, ends at 2 AM next day
+            const startTime = '22:00';
+            const endTime = '+1_02:00';
+            const startMinutes = datetime.parseTimeToMinutes(startTime);
+            const endMinutes = datetime.parseTimeToMinutes(endTime);
+            expect(startMinutes).toBe(22 * 60); // 1320
+            expect(endMinutes).toBe(26 * 60); // 1560
+            // Duration is 4 hours
+            expect(endMinutes - startMinutes).toBe(4 * 60);
+            // Convert back to time strings
+            expect(datetime.minutesToTimeString(startMinutes)).toBe('22:00');
+            expect(datetime.minutesToTimeString(endMinutes, true)).toBe('+1_02:00');
+        });
+    });
+});

package/dist/datetime/__tests__/parse.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parse.test.d.ts.map

package/dist/datetime/__tests__/parse.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.test.d.ts","sourceRoot":"","sources":["../../../src/lib/datetime/__tests__/parse.test.ts"],"names":[],"mappings":""}