@getmicdrop/svelte-components 5.3.12 → 5.3.14

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

@@ -0,0 +1,261 @@
+import { describe, expect, it } from 'vitest';
+import { combineDateAndTime, formatDateTimeForAPI, isNextDayTime, minutesToTimeString, parseDateTimeFromAPI, parseEndOfDay, parseLocalToUTC, parseStartOfDay, parseTimeToMinutes, parseUTCToLocal, stripNextDayPrefix, } from '../parse';
+import { DateTimeError, DateTimeErrorCode } from '../types';
+describe('parse utilities', () => {
+    describe('parseLocalToUTC', () => {
+        it('converts local datetime to UTC', () => {
+            // 7 PM on Dec 25 in LA = 3 AM Dec 26 UTC
+            const local = '2023-12-25T19:00:00';
+            const utc = parseLocalToUTC(local, 'America/Los_Angeles');
+            expect(utc).toBe('2023-12-26T03:00:00.000Z');
+        });
+        it('handles midnight correctly', () => {
+            // Midnight Dec 25 in LA = 8 AM Dec 25 UTC
+            const local = '2023-12-25T00:00:00';
+            const utc = parseLocalToUTC(local, 'America/Los_Angeles');
+            expect(utc).toBe('2023-12-25T08:00:00.000Z');
+        });
+        it('handles different timezones', () => {
+            const local = '2023-12-25T12:00:00';
+            // Noon in NY = 5 PM UTC
+            const nyUtc = parseLocalToUTC(local, 'America/New_York');
+            expect(nyUtc).toBe('2023-12-25T17:00:00.000Z');
+            // Noon in London = noon UTC (winter)
+            const londonUtc = parseLocalToUTC(local, 'Europe/London');
+            expect(londonUtc).toBe('2023-12-25T12:00:00.000Z');
+        });
+        it('handles DST transitions correctly', () => {
+            // March 12, 2023 - DST starts in LA at 2 AM (skips to 3 AM)
+            const beforeDST = '2023-03-12T01:30:00';
+            const afterDST = '2023-03-12T03:30:00';
+            const utcBefore = parseLocalToUTC(beforeDST, 'America/Los_Angeles');
+            const utcAfter = parseLocalToUTC(afterDST, 'America/Los_Angeles');
+            // 1:30 AM PST = 9:30 AM UTC
+            expect(utcBefore).toBe('2023-03-12T09:30:00.000Z');
+            // 3:30 AM PDT = 10:30 AM UTC
+            expect(utcAfter).toBe('2023-03-12T10:30:00.000Z');
+        });
+        it('throws on invalid local datetime', () => {
+            expect(() => parseLocalToUTC('invalid', 'America/Los_Angeles')).toThrow(DateTimeError);
+        });
+        it('throws on empty string', () => {
+            expect(() => parseLocalToUTC('', 'America/Los_Angeles')).toThrow(DateTimeError);
+        });
+        it('throws on null', () => {
+            expect(() => parseLocalToUTC(null, 'America/Los_Angeles')).toThrow();
+        });
+        it('throws on invalid timezone', () => {
+            expect(() => parseLocalToUTC('2023-12-25T19:00:00', 'Invalid/Zone')).toThrow(DateTimeError);
+        });
+    });
+    describe('parseUTCToLocal', () => {
+        it('converts UTC to local datetime', () => {
+            // 3 AM UTC Dec 26 = 7 PM Dec 25 in LA
+            const utc = '2023-12-26T03:00:00Z';
+            const local = parseUTCToLocal(utc, 'America/Los_Angeles');
+            expect(local).toBe('2023-12-25T19:00:00');
+        });
+        it('handles midnight UTC', () => {
+            // Midnight UTC Dec 25 = 4 PM Dec 24 in LA
+            const utc = '2023-12-25T00:00:00Z';
+            const local = parseUTCToLocal(utc, 'America/Los_Angeles');
+            expect(local).toBe('2023-12-24T16:00:00');
+        });
+        it('handles different timezones', () => {
+            const utc = '2023-12-25T17:00:00Z';
+            // 5 PM UTC = noon in NY
+            const nyLocal = parseUTCToLocal(utc, 'America/New_York');
+            expect(nyLocal).toBe('2023-12-25T12:00:00');
+            // 5 PM UTC = 2 AM next day in Tokyo
+            const tokyoLocal = parseUTCToLocal(utc, 'Asia/Tokyo');
+            expect(tokyoLocal).toBe('2023-12-26T02:00:00');
+        });
+        it('throws on invalid UTC string', () => {
+            expect(() => parseUTCToLocal('invalid', 'America/Los_Angeles')).toThrow(DateTimeError);
+        });
+        it('throws on invalid timezone', () => {
+            expect(() => parseUTCToLocal('2023-12-25T17:00:00Z', 'Invalid/Zone')).toThrow(DateTimeError);
+        });
+    });
+    describe('combineDateAndTime', () => {
+        it('combines date and time strings', () => {
+            const result = combineDateAndTime('2023-12-25', '19:00', 'America/Los_Angeles');
+            expect(result).toBe('2023-12-26T03:00:00.000Z');
+        });
+        it('handles 24-hour time format', () => {
+            const result = combineDateAndTime('2023-12-25', '23:30', 'America/Los_Angeles');
+            expect(result).toBe('2023-12-26T07:30:00.000Z');
+        });
+        it('handles midnight', () => {
+            const result = combineDateAndTime('2023-12-25', '00:00', 'America/Los_Angeles');
+            expect(result).toBe('2023-12-25T08:00:00.000Z');
+        });
+        it('handles time with seconds', () => {
+            const result = combineDateAndTime('2023-12-25', '19:30:45', 'America/Los_Angeles');
+            expect(result).toBe('2023-12-26T03:30:45.000Z');
+        });
+        it('throws on invalid date', () => {
+            expect(() => combineDateAndTime('invalid', '19:00', 'America/Los_Angeles')).toThrow(DateTimeError);
+            expect(() => combineDateAndTime('2023-13-45', '19:00', 'America/Los_Angeles')).toThrow(DateTimeError);
+        });
+        it('throws on invalid time', () => {
+            expect(() => combineDateAndTime('2023-12-25', 'invalid', 'America/Los_Angeles')).toThrow(DateTimeError);
+            expect(() => combineDateAndTime('2023-12-25', '25:00', 'America/Los_Angeles')).toThrow(DateTimeError);
+            expect(() => combineDateAndTime('2023-12-25', '12:60', 'America/Los_Angeles')).toThrow(DateTimeError);
+        });
+        it('throws on invalid timezone', () => {
+            expect(() => combineDateAndTime('2023-12-25', '19:00', 'Invalid/Zone')).toThrow(DateTimeError);
+        });
+    });
+    describe('parseDateTimeFromAPI', () => {
+        it('parses UTC to date and time components', () => {
+            const result = parseDateTimeFromAPI('2023-12-26T03:00:00Z', 'America/Los_Angeles');
+            expect(result).toEqual({
+                date: '2023-12-25',
+                time: '19:00',
+            });
+        });
+        it('handles midnight', () => {
+            const result = parseDateTimeFromAPI('2023-12-25T08:00:00Z', 'America/Los_Angeles');
+            expect(result).toEqual({
+                date: '2023-12-25',
+                time: '00:00',
+            });
+        });
+        it('handles different timezones', () => {
+            const utc = '2023-12-25T17:00:00Z';
+            const nyResult = parseDateTimeFromAPI(utc, 'America/New_York');
+            expect(nyResult).toEqual({ date: '2023-12-25', time: '12:00' });
+            const tokyoResult = parseDateTimeFromAPI(utc, 'Asia/Tokyo');
+            expect(tokyoResult).toEqual({ date: '2023-12-26', time: '02:00' });
+        });
+        it('throws on invalid inputs', () => {
+            expect(() => parseDateTimeFromAPI('invalid', 'America/Los_Angeles')).toThrow();
+            expect(() => parseDateTimeFromAPI('2023-12-25T17:00:00Z', 'Invalid/Zone')).toThrow();
+        });
+    });
+    describe('formatDateTimeForAPI', () => {
+        it('formats Date to UTC ISO string', () => {
+            const date = new Date('2023-12-25T19:00:00-08:00');
+            const result = formatDateTimeForAPI(date);
+            expect(result).toBe('2023-12-26T03:00:00.000Z');
+        });
+        it('throws on invalid Date', () => {
+            expect(() => formatDateTimeForAPI(new Date('invalid'))).toThrow(DateTimeError);
+            expect(() => formatDateTimeForAPI(null)).toThrow(DateTimeError);
+            expect(() => formatDateTimeForAPI('string')).toThrow(DateTimeError);
+        });
+    });
+    describe('parseStartOfDay', () => {
+        it('returns UTC for start of day', () => {
+            const result = parseStartOfDay('2023-12-25', 'America/Los_Angeles');
+            // Midnight LA = 8 AM UTC
+            expect(result).toBe('2023-12-25T08:00:00.000Z');
+        });
+        it('handles different timezones', () => {
+            // Midnight NY = 5 AM UTC
+            const nyResult = parseStartOfDay('2023-12-25', 'America/New_York');
+            expect(nyResult).toBe('2023-12-25T05:00:00.000Z');
+        });
+    });
+    describe('parseEndOfDay', () => {
+        it('returns UTC for end of day', () => {
+            const result = parseEndOfDay('2023-12-25', 'America/Los_Angeles');
+            // 11:59:59 PM LA = 7:59:59 AM next day UTC
+            expect(result).toBe('2023-12-26T07:59:59.000Z');
+        });
+    });
+    describe('isNextDayTime', () => {
+        it('returns true for +1_ prefixed times', () => {
+            expect(isNextDayTime('+1_02:00')).toBe(true);
+            expect(isNextDayTime('+1_00:00')).toBe(true);
+            expect(isNextDayTime('+1_23:59')).toBe(true);
+        });
+        it('returns false for regular times', () => {
+            expect(isNextDayTime('14:00')).toBe(false);
+            expect(isNextDayTime('00:00')).toBe(false);
+            expect(isNextDayTime('23:59')).toBe(false);
+        });
+        it('returns false for invalid input', () => {
+            expect(isNextDayTime('')).toBe(false);
+            expect(isNextDayTime(null)).toBe(false);
+            expect(isNextDayTime(undefined)).toBe(false);
+        });
+    });
+    describe('stripNextDayPrefix', () => {
+        it('strips +1_ prefix', () => {
+            expect(stripNextDayPrefix('+1_02:00')).toBe('02:00');
+            expect(stripNextDayPrefix('+1_23:30')).toBe('23:30');
+        });
+        it('returns regular times unchanged', () => {
+            expect(stripNextDayPrefix('14:00')).toBe('14:00');
+            expect(stripNextDayPrefix('00:00')).toBe('00:00');
+        });
+    });
+    describe('parseTimeToMinutes', () => {
+        it('converts time to minutes', () => {
+            expect(parseTimeToMinutes('00:00')).toBe(0);
+            expect(parseTimeToMinutes('01:00')).toBe(60);
+            expect(parseTimeToMinutes('12:00')).toBe(720);
+            expect(parseTimeToMinutes('14:30')).toBe(870);
+            expect(parseTimeToMinutes('23:59')).toBe(1439);
+        });
+        it('handles next-day times', () => {
+            expect(parseTimeToMinutes('+1_00:00')).toBe(1440);
+            expect(parseTimeToMinutes('+1_02:00')).toBe(1560);
+            expect(parseTimeToMinutes('+1_12:00')).toBe(2160);
+        });
+        it('throws on invalid time format', () => {
+            expect(() => parseTimeToMinutes('invalid')).toThrow(DateTimeError);
+            expect(() => parseTimeToMinutes('25:00')).toThrow(DateTimeError);
+            expect(() => parseTimeToMinutes('12:60')).toThrow(DateTimeError);
+        });
+    });
+    describe('minutesToTimeString', () => {
+        it('converts minutes to time string', () => {
+            expect(minutesToTimeString(0)).toBe('00:00');
+            expect(minutesToTimeString(60)).toBe('01:00');
+            expect(minutesToTimeString(720)).toBe('12:00');
+            expect(minutesToTimeString(870)).toBe('14:30');
+            expect(minutesToTimeString(1439)).toBe('23:59');
+        });
+        it('handles overflow minutes without prefix', () => {
+            expect(minutesToTimeString(1440, false)).toBe('00:00');
+            expect(minutesToTimeString(1560, false)).toBe('02:00');
+        });
+        it('adds +1_ prefix for next-day when requested', () => {
+            expect(minutesToTimeString(1440, true)).toBe('+1_00:00');
+            expect(minutesToTimeString(1560, true)).toBe('+1_02:00');
+            expect(minutesToTimeString(2160, true)).toBe('+1_12:00');
+        });
+        it('does not add prefix for same-day minutes', () => {
+            expect(minutesToTimeString(720, true)).toBe('12:00');
+            expect(minutesToTimeString(0, true)).toBe('00:00');
+        });
+    });
+    describe('round-trip conversions', () => {
+        it('local -> UTC -> local preserves value', () => {
+            const original = '2023-12-25T19:00:00';
+            const timezone = 'America/Los_Angeles';
+            const utc = parseLocalToUTC(original, timezone);
+            const roundTrip = parseUTCToLocal(utc, timezone);
+            expect(roundTrip).toBe(original);
+        });
+        it('UTC -> local -> UTC preserves value', () => {
+            const original = '2023-12-26T03:00:00.000Z';
+            const timezone = 'America/Los_Angeles';
+            const local = parseUTCToLocal(original, timezone);
+            const roundTrip = parseLocalToUTC(local, timezone);
+            expect(roundTrip).toBe(original);
+        });
+        it('date + time -> UTC -> date + time preserves values', () => {
+            const date = '2023-12-25';
+            const time = '19:00';
+            const timezone = 'America/Los_Angeles';
+            const utc = combineDateAndTime(date, time, timezone);
+            const parsed = parseDateTimeFromAPI(utc, timezone);
+            expect(parsed.date).toBe(date);
+            expect(parsed.time).toBe(time);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,214 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getTimezoneDisplayName, getTimezoneOffset, getUserTimezone, getVenueTimezone, isDST, isValidTimezone, normalizeTimezone, } from '../timezone';
+import { DateTimeError, DateTimeErrorCode } from '../types';
+describe('timezone utilities', () => {
+    describe('isValidTimezone', () => {
+        it('returns true for valid IANA timezones', () => {
+            expect(isValidTimezone('America/Los_Angeles')).toBe(true);
+            expect(isValidTimezone('America/New_York')).toBe(true);
+            expect(isValidTimezone('Europe/London')).toBe(true);
+            expect(isValidTimezone('Asia/Tokyo')).toBe(true);
+            expect(isValidTimezone('Australia/Sydney')).toBe(true);
+            expect(isValidTimezone('UTC')).toBe(true);
+        });
+        it('returns false for invalid timezones', () => {
+            expect(isValidTimezone('Invalid/Zone')).toBe(false);
+            expect(isValidTimezone('NotATimezone')).toBe(false);
+            expect(isValidTimezone('America/FakeCity')).toBe(false);
+        });
+        it('returns false for timezone abbreviations', () => {
+            expect(isValidTimezone('PST')).toBe(false);
+            expect(isValidTimezone('EST')).toBe(false);
+            expect(isValidTimezone('PDT')).toBe(false);
+            expect(isValidTimezone('CST')).toBe(false);
+        });
+        it('returns false for empty or invalid input', () => {
+            expect(isValidTimezone('')).toBe(false);
+            expect(isValidTimezone(null)).toBe(false);
+            expect(isValidTimezone(undefined)).toBe(false);
+            expect(isValidTimezone(123)).toBe(false);
+        });
+        it('caches validation results', () => {
+            // Call twice - second should use cache
+            const result1 = isValidTimezone('America/Chicago');
+            const result2 = isValidTimezone('America/Chicago');
+            expect(result1).toBe(true);
+            expect(result2).toBe(true);
+        });
+    });
+    describe('getVenueTimezone', () => {
+        it('returns venue timezone when present', () => {
+            const venue = { timezone: 'America/Los_Angeles' };
+            expect(getVenueTimezone(venue)).toBe('America/Los_Angeles');
+        });
+        it('works with venue objects with other properties', () => {
+            const venue = {
+                id: 123,
+                name: 'Jetpack Comedy',
+                timezone: 'America/Denver',
+                city: 'Denver',
+            };
+            expect(getVenueTimezone(venue)).toBe('America/Denver');
+        });
+        it('throws DateTimeError when timezone is missing', () => {
+            const venue = { name: 'Test Venue' };
+            expect(() => getVenueTimezone(venue)).toThrow(DateTimeError);
+            expect(() => getVenueTimezone(venue)).toThrow('Venue timezone is required');
+        });
+        it('throws DateTimeError when timezone is empty string', () => {
+            const venue = { timezone: '' };
+            expect(() => getVenueTimezone(venue)).toThrow(DateTimeError);
+            try {
+                getVenueTimezone(venue);
+            }
+            catch (e) {
+                expect(e.code).toBe(DateTimeErrorCode.MISSING_TIMEZONE);
+            }
+        });
+        it('throws DateTimeError when timezone is whitespace', () => {
+            const venue = { timezone: '   ' };
+            expect(() => getVenueTimezone(venue)).toThrow(DateTimeError);
+        });
+        it('throws DateTimeError when timezone is invalid', () => {
+            const venue = { timezone: 'Invalid/Zone' };
+            expect(() => getVenueTimezone(venue)).toThrow(DateTimeError);
+            try {
+                getVenueTimezone(venue);
+            }
+            catch (e) {
+                expect(e.code).toBe(DateTimeErrorCode.INVALID_TIMEZONE);
+            }
+        });
+        it('throws when venue is null or undefined', () => {
+            expect(() => getVenueTimezone(null)).toThrow();
+            expect(() => getVenueTimezone(undefined)).toThrow();
+        });
+    });
+    describe('getUserTimezone', () => {
+        it('returns a valid timezone', () => {
+            const tz = getUserTimezone();
+            expect(typeof tz).toBe('string');
+            expect(isValidTimezone(tz)).toBe(true);
+        });
+        it('returns the browser timezone', () => {
+            const tz = getUserTimezone();
+            // This should match what Intl reports
+            expect(tz).toBe(Intl.DateTimeFormat().resolvedOptions().timeZone);
+        });
+    });
+    describe('getTimezoneOffset', () => {
+        it('returns offset string for valid timezone', () => {
+            const offset = getTimezoneOffset('America/Los_Angeles');
+            expect(offset).toMatch(/P[SD]T \(UTC[+-]\d+\)/);
+        });
+        it('returns correct offset for UTC', () => {
+            const offset = getTimezoneOffset('UTC');
+            expect(offset).toMatch(/UTC.*\(UTC[+-]?0?\)/);
+        });
+        it('returns different offsets for different timezones', () => {
+            const laOffset = getTimezoneOffset('America/Los_Angeles');
+            const nyOffset = getTimezoneOffset('America/New_York');
+            expect(laOffset).not.toBe(nyOffset);
+        });
+        it('respects DST when given specific date', () => {
+            // January (no DST)
+            const winterDate = new Date('2023-01-15T12:00:00Z');
+            const winterOffset = getTimezoneOffset('America/Los_Angeles', winterDate);
+            expect(winterOffset).toContain('PST');
+            // July (DST)
+            const summerDate = new Date('2023-07-15T12:00:00Z');
+            const summerOffset = getTimezoneOffset('America/Los_Angeles', summerDate);
+            expect(summerOffset).toContain('PDT');
+        });
+        it('throws DateTimeError for invalid timezone', () => {
+            expect(() => getTimezoneOffset('Invalid/Zone')).toThrow(DateTimeError);
+            try {
+                getTimezoneOffset('Invalid/Zone');
+            }
+            catch (e) {
+                expect(e.code).toBe(DateTimeErrorCode.INVALID_TIMEZONE);
+            }
+        });
+    });
+    describe('getTimezoneDisplayName', () => {
+        it('returns display name for valid timezone', () => {
+            const name = getTimezoneDisplayName('America/Los_Angeles');
+            expect(name).toMatch(/Pacific/);
+        });
+        it('returns display name for various timezones', () => {
+            expect(getTimezoneDisplayName('America/New_York')).toMatch(/Eastern/);
+            expect(getTimezoneDisplayName('Europe/London')).toMatch(/British|Greenwich/);
+            expect(getTimezoneDisplayName('Asia/Tokyo')).toMatch(/Japan/);
+        });
+        it('throws DateTimeError for invalid timezone', () => {
+            expect(() => getTimezoneDisplayName('Invalid/Zone')).toThrow(DateTimeError);
+        });
+    });
+    describe('normalizeTimezone', () => {
+        it('returns valid timezone as-is', () => {
+            expect(normalizeTimezone('America/Los_Angeles')).toBe('America/Los_Angeles');
+            expect(normalizeTimezone('Europe/London')).toBe('Europe/London');
+        });
+        it('normalizes common US abbreviations', () => {
+            expect(normalizeTimezone('PST')).toBe('America/Los_Angeles');
+            expect(normalizeTimezone('PDT')).toBe('America/Los_Angeles');
+            expect(normalizeTimezone('PT')).toBe('America/Los_Angeles');
+            expect(normalizeTimezone('EST')).toBe('America/New_York');
+            expect(normalizeTimezone('EDT')).toBe('America/New_York');
+            expect(normalizeTimezone('ET')).toBe('America/New_York');
+            expect(normalizeTimezone('CST')).toBe('America/Chicago');
+            expect(normalizeTimezone('CT')).toBe('America/Chicago');
+            expect(normalizeTimezone('MST')).toBe('America/Denver');
+            expect(normalizeTimezone('MT')).toBe('America/Denver');
+        });
+        it('normalizes case-insensitively', () => {
+            expect(normalizeTimezone('pst')).toBe('America/Los_Angeles');
+            expect(normalizeTimezone('Pacific')).toBe('America/Los_Angeles');
+            expect(normalizeTimezone('EASTERN')).toBe('America/New_York');
+        });
+        it('normalizes UTC variants', () => {
+            expect(normalizeTimezone('UTC')).toBe('UTC');
+            expect(normalizeTimezone('GMT')).toBe('UTC');
+            // 'utc' lowercase is actually valid in Intl API, so it passes through
+            expect(normalizeTimezone('utc')).toBe('utc');
+        });
+        it('trims whitespace', () => {
+            expect(normalizeTimezone('  America/Los_Angeles  ')).toBe('America/Los_Angeles');
+            expect(normalizeTimezone('  PST  ')).toBe('America/Los_Angeles');
+        });
+        it('throws DateTimeError for empty input', () => {
+            expect(() => normalizeTimezone('')).toThrow(DateTimeError);
+            expect(() => normalizeTimezone(null)).toThrow(DateTimeError);
+            expect(() => normalizeTimezone(undefined)).toThrow(DateTimeError);
+        });
+        it('throws DateTimeError for unknown abbreviations', () => {
+            expect(() => normalizeTimezone('UNKNOWN')).toThrow(DateTimeError);
+            expect(() => normalizeTimezone('XYZ')).toThrow(DateTimeError);
+        });
+    });
+    describe('isDST', () => {
+        it('returns true during daylight saving time', () => {
+            // July is DST in LA
+            const summerDate = new Date('2023-07-15T12:00:00Z');
+            expect(isDST('America/Los_Angeles', summerDate)).toBe(true);
+        });
+        it('returns false during standard time', () => {
+            // January is standard time in LA
+            const winterDate = new Date('2023-01-15T12:00:00Z');
+            expect(isDST('America/Los_Angeles', winterDate)).toBe(false);
+        });
+        it('returns false for timezones without DST', () => {
+            // Arizona doesn't observe DST
+            const summerDate = new Date('2023-07-15T12:00:00Z');
+            expect(isDST('America/Phoenix', summerDate)).toBe(false);
+            const winterDate = new Date('2023-01-15T12:00:00Z');
+            expect(isDST('America/Phoenix', winterDate)).toBe(false);
+        });
+        it('returns false for UTC', () => {
+            expect(isDST('UTC')).toBe(false);
+        });
+        it('throws DateTimeError for invalid timezone', () => {
+            expect(() => isDST('Invalid/Zone')).toThrow(DateTimeError);
+        });
+    });
+});

package/dist/datetime/constants.d.ts

@@ -0,0 +1,133 @@
+/**
+ * DateTime Constants
+ *
+ * Centralized constants for datetime operations.
+ * Use these instead of magic numbers throughout the codebase.
+ *
+ * @module datetime/constants
+ */
+/**
+ * Duration constants in milliseconds.
+ */
+export declare const DURATIONS: {
+    /** One second in milliseconds */
+    readonly SECOND: 1000;
+    /** One minute in milliseconds */
+    readonly MINUTE: number;
+    /** One hour in milliseconds */
+    readonly HOUR: number;
+    /** One day in milliseconds */
+    readonly DAY: number;
+    /** One week in milliseconds */
+    readonly WEEK: number;
+};
+/**
+ * Duration constants in minutes.
+ */
+export declare const DURATIONS_MINUTES: {
+    /** One hour in minutes */
+    readonly HOUR: 60;
+    /** One day in minutes */
+    readonly DAY: number;
+    /** One week in minutes */
+    readonly WEEK: number;
+};
+/**
+ * Date format strings for use with date-fns.
+ */
+export declare const DATE_FORMATS: {
+    /** API format: UTC ISO string */
+    readonly API: "yyyy-MM-dd'T'HH:mm:ss'Z'";
+    /** Date for API without time */
+    readonly API_DATE: "yyyy-MM-dd";
+    /** Display date (e.g., "Dec 20, 2025") */
+    readonly DISPLAY_DATE: "MMM d, yyyy";
+    /** Display date without year (e.g., "Dec 20") */
+    readonly DISPLAY_DATE_SHORT: "MMM d";
+    /** Display time (e.g., "7:00 PM") */
+    readonly DISPLAY_TIME: "h:mm a";
+    /** Display time with seconds (e.g., "7:00:00 PM") */
+    readonly DISPLAY_TIME_SECONDS: "h:mm:ss a";
+    /** Display datetime (e.g., "Dec 20, 2025 at 7:00 PM") */
+    readonly DISPLAY_DATETIME: "MMM d, yyyy 'at' h:mm a";
+    /** Display full datetime with day (e.g., "Mon, Dec 20, 2025 at 7:00 PM") */
+    readonly DISPLAY_DATETIME_FULL: "EEE, MMM d, yyyy 'at' h:mm a";
+    /** Day of week short (e.g., "Mon") */
+    readonly DAY_SHORT: "EEE";
+    /** Day of week full (e.g., "Monday") */
+    readonly DAY_FULL: "EEEE";
+    /** Month short (e.g., "Dec") */
+    readonly MONTH_SHORT: "MMM";
+    /** Month full (e.g., "December") */
+    readonly MONTH_FULL: "MMMM";
+    /** Year only (e.g., "2025") */
+    readonly YEAR: "yyyy";
+    /** 24-hour time (e.g., "19:00") */
+    readonly TIME_24H: "HH:mm";
+};
+/**
+ * Commonly used US timezones for quick selection.
+ */
+export declare const COMMON_US_TIMEZONES: readonly [{
+    readonly id: "America/Los_Angeles";
+    readonly label: "Pacific Time (PT)";
+    readonly abbr: "PT";
+}, {
+    readonly id: "America/Denver";
+    readonly label: "Mountain Time (MT)";
+    readonly abbr: "MT";
+}, {
+    readonly id: "America/Chicago";
+    readonly label: "Central Time (CT)";
+    readonly abbr: "CT";
+}, {
+    readonly id: "America/New_York";
+    readonly label: "Eastern Time (ET)";
+    readonly abbr: "ET";
+}, {
+    readonly id: "America/Phoenix";
+    readonly label: "Arizona (no DST)";
+    readonly abbr: "AZ";
+}, {
+    readonly id: "Pacific/Honolulu";
+    readonly label: "Hawaii Time (HT)";
+    readonly abbr: "HT";
+}, {
+    readonly id: "America/Anchorage";
+    readonly label: "Alaska Time (AKT)";
+    readonly abbr: "AKT";
+}];
+/**
+ * Default timezone when none is specified (should rarely be used).
+ * Prefer explicitly passing timezone in all operations.
+ */
+export declare const DEFAULT_TIMEZONE: "America/Los_Angeles";
+/**
+ * Relative time thresholds for formatRelativeTime.
+ */
+export declare const RELATIVE_TIME_THRESHOLDS: {
+    /** Under this many seconds, show "just now" */
+    readonly JUST_NOW_SECONDS: 60;
+    /** Under this many minutes, show "X minutes ago/from now" */
+    readonly MINUTES_THRESHOLD: 60;
+    /** Under this many hours, show "X hours ago/from now" */
+    readonly HOURS_THRESHOLD: 24;
+    /** Under this many days, show "X days ago/from now" */
+    readonly DAYS_THRESHOLD: 7;
+    /** Under this many weeks, show "X weeks ago/from now" */
+    readonly WEEKS_THRESHOLD: 4;
+};
+/**
+ * MicDrop-specific event defaults.
+ */
+export declare const EVENT_DEFAULTS: {
+    /** Default event duration in minutes */
+    readonly DEFAULT_DURATION_MINUTES: 120;
+    /** Minimum event duration in minutes */
+    readonly MIN_DURATION_MINUTES: 15;
+    /** Maximum event duration in minutes (24 hours) */
+    readonly MAX_DURATION_MINUTES: number;
+    /** Default doors open time before event start (minutes) */
+    readonly DEFAULT_DOORS_BEFORE_MINUTES: 30;
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/datetime/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/lib/datetime/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS;IACpB,iCAAiC;;IAEjC,iCAAiC;;IAEjC,+BAA+B;;IAE/B,8BAA8B;;IAE9B,+BAA+B;;CAEvB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC5B,0BAA0B;;IAE1B,yBAAyB;;IAEzB,0BAA0B;;CAElB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,YAAY;IACvB,iCAAiC;;IAEjC,gCAAgC;;IAEhC,0CAA0C;;IAE1C,iDAAiD;;IAEjD,qCAAqC;;IAErC,qDAAqD;;IAErD,yDAAyD;;IAEzD,4EAA4E;;IAE5E,sCAAsC;;IAEtC,wCAAwC;;IAExC,gCAAgC;;IAEhC,oCAAoC;;IAEpC,+BAA+B;;IAE/B,mCAAmC;;CAE3B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQtB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAG,qBAA8B,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,wBAAwB;IACnC,+CAA+C;;IAE/C,6DAA6D;;IAE7D,yDAAyD;;IAEzD,uDAAuD;;IAEvD,yDAAyD;;CAEjD,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,cAAc;IACzB,wCAAwC;;IAExC,wCAAwC;;IAExC,mDAAmD;;IAEnD,2DAA2D;;CAEnD,CAAC"}