@getmicdrop/svelte-components 5.4.0 → 5.4.2

package/dist/components/Layout/__tests__/Stack.test.js

@@ -0,0 +1,267 @@
+import { describe, expect, it } from 'vitest';
+import { render } from '@testing-library/svelte';
+import Stack from '../Stack.svelte';
+describe('Stack', () => {
+    describe('basic rendering', () => {
+        it('renders as a div by default', () => {
+            const { container } = render(Stack);
+            expect(container.querySelector('div')).toBeTruthy();
+        });
+        it('applies flex and flex-col classes by default', () => {
+            const { container } = render(Stack);
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('flex')).toBe(true);
+            expect(div?.classList.contains('flex-col')).toBe(true);
+        });
+        it('applies default gap-4 class', () => {
+            const { container } = render(Stack);
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('gap-4')).toBe(true);
+        });
+    });
+    describe('direction prop', () => {
+        it('applies flex-col for vertical direction', () => {
+            const { container } = render(Stack, { direction: 'vertical' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('flex-col')).toBe(true);
+            expect(div?.classList.contains('flex-row')).toBe(false);
+        });
+        it('applies flex-row for horizontal direction', () => {
+            const { container } = render(Stack, { direction: 'horizontal' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('flex-row')).toBe(true);
+            expect(div?.classList.contains('flex-col')).toBe(false);
+        });
+    });
+    describe('gap prop', () => {
+        describe('numeric values', () => {
+            it('applies gap-0 for gap="0"', () => {
+                const { container } = render(Stack, { gap: '0' });
+                const div = container.querySelector('div');
+                expect(div?.classList.contains('gap-0')).toBe(true);
+            });
+            it('applies gap-1 for gap="1"', () => {
+                const { container } = render(Stack, { gap: '1' });
+                const div = container.querySelector('div');
+                expect(div?.classList.contains('gap-1')).toBe(true);
+            });
+            it('applies gap-8 for gap="8"', () => {
+                const { container } = render(Stack, { gap: '8' });
+                const div = container.querySelector('div');
+                expect(div?.classList.contains('gap-8')).toBe(true);
+            });
+        });
+        describe('semantic values', () => {
+            it('applies gap-4 for gap="content"', () => {
+                const { container } = render(Stack, { gap: 'content' });
+                const div = container.querySelector('div');
+                expect(div?.classList.contains('gap-4')).toBe(true);
+            });
+            it('applies gap-6 for gap="section"', () => {
+                const { container } = render(Stack, { gap: 'section' });
+                const div = container.querySelector('div');
+                expect(div?.classList.contains('gap-6')).toBe(true);
+            });
+            it('applies gap-8 for gap="layout"', () => {
+                const { container } = render(Stack, { gap: 'layout' });
+                const div = container.querySelector('div');
+                expect(div?.classList.contains('gap-8')).toBe(true);
+            });
+            it('applies gap-12 for gap="page"', () => {
+                const { container } = render(Stack, { gap: 'page' });
+                const div = container.querySelector('div');
+                expect(div?.classList.contains('gap-12')).toBe(true);
+            });
+        });
+        describe('legacy values', () => {
+            it('applies gap-0 for gap="none"', () => {
+                const { container } = render(Stack, { gap: 'none' });
+                const div = container.querySelector('div');
+                expect(div?.classList.contains('gap-0')).toBe(true);
+            });
+            it('applies gap-2 for gap="sm"', () => {
+                const { container } = render(Stack, { gap: 'sm' });
+                const div = container.querySelector('div');
+                expect(div?.classList.contains('gap-2')).toBe(true);
+            });
+            it('applies gap-4 for gap="md"', () => {
+                const { container } = render(Stack, { gap: 'md' });
+                const div = container.querySelector('div');
+                expect(div?.classList.contains('gap-4')).toBe(true);
+            });
+            it('applies gap-6 for gap="lg"', () => {
+                const { container } = render(Stack, { gap: 'lg' });
+                const div = container.querySelector('div');
+                expect(div?.classList.contains('gap-6')).toBe(true);
+            });
+        });
+    });
+    describe('align prop', () => {
+        it('applies items-start for align="start"', () => {
+            const { container } = render(Stack, { align: 'start' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('items-start')).toBe(true);
+        });
+        it('applies items-center for align="center"', () => {
+            const { container } = render(Stack, { align: 'center' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('items-center')).toBe(true);
+        });
+        it('applies items-end for align="end"', () => {
+            const { container } = render(Stack, { align: 'end' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('items-end')).toBe(true);
+        });
+        it('applies items-stretch for align="stretch"', () => {
+            const { container } = render(Stack, { align: 'stretch' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('items-stretch')).toBe(true);
+        });
+        it('applies items-baseline for align="baseline"', () => {
+            const { container } = render(Stack, { align: 'baseline' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('items-baseline')).toBe(true);
+        });
+        it('does not apply align class when prop is not provided', () => {
+            const { container } = render(Stack);
+            const div = container.querySelector('div');
+            const hasAlignClass = Array.from(div?.classList || []).some(c => c.startsWith('items-'));
+            expect(hasAlignClass).toBe(false);
+        });
+    });
+    describe('justify prop', () => {
+        it('applies justify-start for justify="start"', () => {
+            const { container } = render(Stack, { justify: 'start' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('justify-start')).toBe(true);
+        });
+        it('applies justify-center for justify="center"', () => {
+            const { container } = render(Stack, { justify: 'center' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('justify-center')).toBe(true);
+        });
+        it('applies justify-end for justify="end"', () => {
+            const { container } = render(Stack, { justify: 'end' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('justify-end')).toBe(true);
+        });
+        it('applies justify-between for justify="between"', () => {
+            const { container } = render(Stack, { justify: 'between' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('justify-between')).toBe(true);
+        });
+        it('applies justify-around for justify="around"', () => {
+            const { container } = render(Stack, { justify: 'around' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('justify-around')).toBe(true);
+        });
+        it('applies justify-evenly for justify="evenly"', () => {
+            const { container } = render(Stack, { justify: 'evenly' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('justify-evenly')).toBe(true);
+        });
+        it('does not apply justify class when prop is not provided', () => {
+            const { container } = render(Stack);
+            const div = container.querySelector('div');
+            const hasJustifyClass = Array.from(div?.classList || []).some(c => c.startsWith('justify-'));
+            expect(hasJustifyClass).toBe(false);
+        });
+    });
+    describe('wrap prop', () => {
+        it('does not apply flex-wrap by default', () => {
+            const { container } = render(Stack);
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('flex-wrap')).toBe(false);
+        });
+        it('applies flex-wrap when wrap=true', () => {
+            const { container } = render(Stack, { wrap: true });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('flex-wrap')).toBe(true);
+        });
+        it('does not apply flex-wrap when wrap=false', () => {
+            const { container } = render(Stack, { wrap: false });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('flex-wrap')).toBe(false);
+        });
+    });
+    describe('as prop', () => {
+        it('renders as div by default', () => {
+            const { container } = render(Stack);
+            expect(container.querySelector('div')).toBeTruthy();
+            expect(container.querySelector('section')).toBeFalsy();
+        });
+        it('renders as section when as="section"', () => {
+            const { container } = render(Stack, { as: 'section' });
+            expect(container.querySelector('section')).toBeTruthy();
+            expect(container.querySelector('div')).toBeFalsy();
+        });
+        it('renders as article when as="article"', () => {
+            const { container } = render(Stack, { as: 'article' });
+            expect(container.querySelector('article')).toBeTruthy();
+        });
+        it('renders as aside when as="aside"', () => {
+            const { container } = render(Stack, { as: 'aside' });
+            expect(container.querySelector('aside')).toBeTruthy();
+        });
+        it('renders as main when as="main"', () => {
+            const { container } = render(Stack, { as: 'main' });
+            expect(container.querySelector('main')).toBeTruthy();
+        });
+        it('renders as nav when as="nav"', () => {
+            const { container } = render(Stack, { as: 'nav' });
+            expect(container.querySelector('nav')).toBeTruthy();
+        });
+        it('renders as ul when as="ul"', () => {
+            const { container } = render(Stack, { as: 'ul' });
+            expect(container.querySelector('ul')).toBeTruthy();
+        });
+        it('renders as ol when as="ol"', () => {
+            const { container } = render(Stack, { as: 'ol' });
+            expect(container.querySelector('ol')).toBeTruthy();
+        });
+    });
+    describe('class prop', () => {
+        it('applies custom classes', () => {
+            const { container } = render(Stack, { class: 'custom-class' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('custom-class')).toBe(true);
+        });
+        it('preserves default classes when adding custom classes', () => {
+            const { container } = render(Stack, { class: 'custom-class' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('flex')).toBe(true);
+            expect(div?.classList.contains('flex-col')).toBe(true);
+            expect(div?.classList.contains('gap-4')).toBe(true);
+            expect(div?.classList.contains('custom-class')).toBe(true);
+        });
+        it('supports multiple custom classes', () => {
+            const { container } = render(Stack, { class: 'class-a class-b class-c' });
+            const div = container.querySelector('div');
+            expect(div?.classList.contains('class-a')).toBe(true);
+            expect(div?.classList.contains('class-b')).toBe(true);
+            expect(div?.classList.contains('class-c')).toBe(true);
+        });
+    });
+    describe('combined props', () => {
+        it('applies all props correctly together', () => {
+            const { container } = render(Stack, {
+                direction: 'horizontal',
+                gap: 'section',
+                align: 'center',
+                justify: 'between',
+                wrap: true,
+                as: 'nav',
+                class: 'my-nav',
+            });
+            const nav = container.querySelector('nav');
+            expect(nav).toBeTruthy();
+            expect(nav?.classList.contains('flex')).toBe(true);
+            expect(nav?.classList.contains('flex-row')).toBe(true);
+            expect(nav?.classList.contains('gap-6')).toBe(true);
+            expect(nav?.classList.contains('items-center')).toBe(true);
+            expect(nav?.classList.contains('justify-between')).toBe(true);
+            expect(nav?.classList.contains('flex-wrap')).toBe(true);
+            expect(nav?.classList.contains('my-nav')).toBe(true);
+        });
+    });
+});

package/dist/constants/formOptions.spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formOptions.spec.d.ts","sourceRoot":"","sources":["../../src/lib/constants/formOptions.spec.js"],"names":[],"mappings":""}
+{"version":3,"file":"formOptions.spec.d.ts","sourceRoot":"","sources":["../../src/lib/constants/formOptions.spec.ts"],"names":[],"mappings":""}

package/dist/constants/formOptions.spec.js

@@ -1,88 +1,75 @@
 import { describe, it, expect } from 'vitest';
 import { GENDER_OPTIONS, ETHNICITY_OPTIONS } from './formOptions.js';
-
 describe('formOptions', () => {
-  describe('GENDER_OPTIONS', () => {
-    it('exports gender options array', () => {
-      expect(GENDER_OPTIONS).toBeDefined();
-      expect(Array.isArray(GENDER_OPTIONS)).toBe(true);
+    describe('GENDER_OPTIONS', () => {
+        it('exports gender options array', () => {
+            expect(GENDER_OPTIONS).toBeDefined();
+            expect(Array.isArray(GENDER_OPTIONS)).toBe(true);
+        });
+        it('has three options', () => {
+            expect(GENDER_OPTIONS.length).toBe(3);
+        });
+        it('contains Male option with value 1', () => {
+            const male = GENDER_OPTIONS.find(opt => opt.name === 'Male');
+            expect(male).toBeDefined();
+            expect(male.value).toBe(1);
+        });
+        it('contains Female option with value 2', () => {
+            const female = GENDER_OPTIONS.find(opt => opt.name === 'Female');
+            expect(female).toBeDefined();
+            expect(female.value).toBe(2);
+        });
+        it('contains Non-Binary option with value 3', () => {
+            const nonBinary = GENDER_OPTIONS.find(opt => opt.name === 'Non-Binary');
+            expect(nonBinary).toBeDefined();
+            expect(nonBinary.value).toBe(3);
+        });
+        it('each option has name and value properties', () => {
+            GENDER_OPTIONS.forEach(option => {
+                expect(option).toHaveProperty('name');
+                expect(option).toHaveProperty('value');
+                expect(typeof option.name).toBe('string');
+                expect(typeof option.value).toBe('number');
+            });
+        });
     });
-
-    it('has three options', () => {
-      expect(GENDER_OPTIONS.length).toBe(3);
+    describe('ETHNICITY_OPTIONS', () => {
+        it('exports ethnicity options array', () => {
+            expect(ETHNICITY_OPTIONS).toBeDefined();
+            expect(Array.isArray(ETHNICITY_OPTIONS)).toBe(true);
+        });
+        it('has seven options', () => {
+            expect(ETHNICITY_OPTIONS.length).toBe(7);
+        });
+        it('contains all expected ethnicities', () => {
+            const names = ETHNICITY_OPTIONS.map(opt => opt.name);
+            expect(names).toContain('American Indian or Alaska Native');
+            expect(names).toContain('Asian');
+            expect(names).toContain('Black or African American');
+            expect(names).toContain('Hispanic or Latino');
+            expect(names).toContain('Middle Eastern or North African');
+            expect(names).toContain('Native Hawaiian or Pacific Islander');
+            expect(names).toContain('White');
+        });
+        it('has values 0 through 6', () => {
+            const values = ETHNICITY_OPTIONS.map(opt => opt.value).sort((a, b) => a - b);
+            expect(values).toEqual([0, 1, 2, 3, 4, 5, 6]);
+        });
+        it('each option has name and value properties', () => {
+            ETHNICITY_OPTIONS.forEach(option => {
+                expect(option).toHaveProperty('name');
+                expect(option).toHaveProperty('value');
+                expect(typeof option.name).toBe('string');
+                expect(typeof option.value).toBe('number');
+            });
+        });
+        it('American Indian or Alaska Native has value 0', () => {
+            const option = ETHNICITY_OPTIONS.find(opt => opt.name === 'American Indian or Alaska Native');
+            expect(option.value).toBe(0);
+        });
+        it('White has value 6', () => {
+            const option = ETHNICITY_OPTIONS.find(opt => opt.name === 'White');
+            expect(option.value).toBe(6);
+        });
     });
-
-    it('contains Male option with value 1', () => {
-      const male = GENDER_OPTIONS.find(opt => opt.name === 'Male');
-      expect(male).toBeDefined();
-      expect(male.value).toBe(1);
-    });
-
-    it('contains Female option with value 2', () => {
-      const female = GENDER_OPTIONS.find(opt => opt.name === 'Female');
-      expect(female).toBeDefined();
-      expect(female.value).toBe(2);
-    });
-
-    it('contains Non-Binary option with value 3', () => {
-      const nonBinary = GENDER_OPTIONS.find(opt => opt.name === 'Non-Binary');
-      expect(nonBinary).toBeDefined();
-      expect(nonBinary.value).toBe(3);
-    });
-
-    it('each option has name and value properties', () => {
-      GENDER_OPTIONS.forEach(option => {
-        expect(option).toHaveProperty('name');
-        expect(option).toHaveProperty('value');
-        expect(typeof option.name).toBe('string');
-        expect(typeof option.value).toBe('number');
-      });
-    });
-  });
-
-  describe('ETHNICITY_OPTIONS', () => {
-    it('exports ethnicity options array', () => {
-      expect(ETHNICITY_OPTIONS).toBeDefined();
-      expect(Array.isArray(ETHNICITY_OPTIONS)).toBe(true);
-    });
-
-    it('has seven options', () => {
-      expect(ETHNICITY_OPTIONS.length).toBe(7);
-    });
-
-    it('contains all expected ethnicities', () => {
-      const names = ETHNICITY_OPTIONS.map(opt => opt.name);
-      expect(names).toContain('American Indian or Alaska Native');
-      expect(names).toContain('Asian');
-      expect(names).toContain('Black or African American');
-      expect(names).toContain('Hispanic or Latino');
-      expect(names).toContain('Middle Eastern or North African');
-      expect(names).toContain('Native Hawaiian or Pacific Islander');
-      expect(names).toContain('White');
-    });
-
-    it('has values 0 through 6', () => {
-      const values = ETHNICITY_OPTIONS.map(opt => opt.value).sort((a, b) => a - b);
-      expect(values).toEqual([0, 1, 2, 3, 4, 5, 6]);
-    });
-
-    it('each option has name and value properties', () => {
-      ETHNICITY_OPTIONS.forEach(option => {
-        expect(option).toHaveProperty('name');
-        expect(option).toHaveProperty('value');
-        expect(typeof option.name).toBe('string');
-        expect(typeof option.value).toBe('number');
-      });
-    });
-
-    it('American Indian or Alaska Native has value 0', () => {
-      const option = ETHNICITY_OPTIONS.find(opt => opt.name === 'American Indian or Alaska Native');
-      expect(option.value).toBe(0);
-    });
-
-    it('White has value 6', () => {
-      const option = ETHNICITY_OPTIONS.find(opt => opt.name === 'White');
-      expect(option.value).toBe(6);
-    });
-  });
 });

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

@@ -1,5 +1,5 @@
 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 { formatCleanTimeRange, formatDateRange, formatDayOfWeek, formatEventDate, formatEventDateTime, formatEventTime, formatHour, formatMonth, formatNotificationTime, formatRelativeTime, formatTimeRange, getDateInTimezone, getDateParts, getHourInTimezone, isToday, } from '../format';
 import { DateTimeError, DateTimeErrorCode } from '../types';
 describe('format utilities', () => {
     describe('formatEventTime', () => {
@@ -265,4 +265,84 @@ describe('format utilities', () => {
             expect(getDateInTimezone(utc, 'America/Los_Angeles')).toBe('2023-12-24');
         });
     });
+    describe('formatHour', () => {
+        it('formats morning hours correctly', () => {
+            expect(formatHour(8)).toBe('8 AM');
+            expect(formatHour(11)).toBe('11 AM');
+        });
+        it('formats afternoon hours correctly', () => {
+            expect(formatHour(13)).toBe('1 PM');
+            expect(formatHour(20)).toBe('8 PM');
+            expect(formatHour(23)).toBe('11 PM');
+        });
+        it('formats midnight correctly', () => {
+            expect(formatHour(0)).toBe('12 AM');
+        });
+        it('formats noon correctly', () => {
+            expect(formatHour(12)).toBe('12 PM');
+        });
+        it('handles edge case of 24', () => {
+            // 24 % 12 = 0, and 24 >= 12, so it shows 12 PM
+            // This is technically valid behavior - callers should normalize to 0-23
+            expect(formatHour(24)).toBe('12 PM');
+        });
+    });
+    describe('isToday', () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date('2023-12-25T12:00:00Z'));
+        });
+        afterEach(() => {
+            vi.useRealTimers();
+        });
+        it('returns true for today in the specified timezone', () => {
+            // Current time is Dec 25, 12:00 UTC = Dec 25, 4:00 AM in LA
+            const todayInLA = '2023-12-25T20:00:00Z'; // Dec 25, 12:00 PM in LA
+            expect(isToday(todayInLA, 'America/Los_Angeles')).toBe(true);
+        });
+        it('returns false for yesterday', () => {
+            const yesterday = '2023-12-24T12:00:00Z';
+            expect(isToday(yesterday, 'America/Los_Angeles')).toBe(false);
+        });
+        it('returns false for tomorrow', () => {
+            const tomorrow = '2023-12-26T12:00:00Z';
+            expect(isToday(tomorrow, 'America/Los_Angeles')).toBe(false);
+        });
+        it('handles timezone boundary correctly', () => {
+            // 3 AM UTC on Dec 25 = 7 PM Dec 24 in LA
+            // Current "now" is Dec 25, 12:00 UTC = Dec 25, 4:00 AM in LA
+            const utc = '2023-12-25T03:00:00Z';
+            expect(isToday(utc, 'America/Los_Angeles')).toBe(false); // It's Dec 24 in LA
+        });
+        it('throws on invalid timezone', () => {
+            expect(() => isToday('2023-12-25T12:00:00Z', 'Invalid/Zone')).toThrow();
+        });
+    });
+    describe('formatCleanTimeRange', () => {
+        it('omits minutes when times are on the hour', () => {
+            // 3 AM UTC = 7 PM in LA, 6 AM UTC = 10 PM in LA
+            const start = '2023-12-25T03:00:00Z';
+            const end = '2023-12-25T06:00:00Z';
+            expect(formatCleanTimeRange(start, end, 'America/Los_Angeles')).toBe('7 PM - 10 PM');
+        });
+        it('includes minutes when not on the hour', () => {
+            const start = '2023-12-25T03:30:00Z';
+            const end = '2023-12-25T06:00:00Z';
+            expect(formatCleanTimeRange(start, end, 'America/Los_Angeles')).toBe('7:30 PM - 10 PM');
+        });
+        it('handles both times with minutes', () => {
+            const start = '2023-12-25T03:15:00Z';
+            const end = '2023-12-25T06:45:00Z';
+            expect(formatCleanTimeRange(start, end, 'America/Los_Angeles')).toBe('7:15 PM - 10:45 PM');
+        });
+        it('handles midnight correctly', () => {
+            // 8 AM UTC = midnight in LA
+            const start = '2023-12-25T08:00:00Z';
+            const end = '2023-12-25T10:00:00Z';
+            expect(formatCleanTimeRange(start, end, 'America/Los_Angeles')).toBe('12 AM - 2 AM');
+        });
+        it('throws on invalid inputs', () => {
+            expect(() => formatCleanTimeRange('invalid', '2023-12-25T06:00:00Z', 'America/Los_Angeles')).toThrow();
+        });
+    });
 });

package/dist/datetime/format.d.ts

@@ -155,4 +155,78 @@ export declare function getHourInTimezone(utcIso: ISODateString, timezone: Timez
  * @returns Date string in YYYY-MM-DD format
  */
 export declare function getDateInTimezone(utcIso: ISODateString, timezone: TimezoneId): string;
+/**
+ * Formats an hour number (0-23) to a display string with AM/PM.
+ * This is a simple utility that doesn't require timezone since it works
+ * with a raw hour number, not a datetime.
+ *
+ * @param hour - Hour number (0-23)
+ * @returns Formatted hour string (e.g., "8 PM", "12 AM")
+ *
+ * @example
+ * formatHour(8)  // "8 AM"
+ * formatHour(20) // "8 PM"
+ * formatHour(0)  // "12 AM"
+ * formatHour(12) // "12 PM"
+ */
+export declare function formatHour(hour: number): string;
+/**
+ * Checks if a UTC datetime represents today in the specified timezone.
+ *
+ * @param utcIso - UTC ISO datetime string
+ * @param timezone - IANA timezone ID
+ * @returns True if the date is today in the given timezone
+ * @throws {DateTimeError} If timezone or ISO string is invalid
+ *
+ * @example
+ * isToday('2025-01-04T19:00:00Z', 'America/Los_Angeles')
+ * // true (if today is Jan 4, 2025 in LA)
+ */
+export declare function isToday(utcIso: ISODateString, timezone: TimezoneId): boolean;
+/**
+ * Formats a date for simple display (e.g., lists, dropdowns).
+ * Format: "Jan 15, 2024"
+ *
+ * This is a convenience function that defaults to UTC when no timezone is provided.
+ * For timezone-aware formatting, use formatEventDate instead.
+ *
+ * @param utcIso - UTC ISO datetime string
+ * @param timezone - Optional IANA timezone ID (defaults to 'UTC')
+ * @returns Formatted date string (e.g., "Jan 15, 2024")
+ * @throws {DateTimeError} If ISO string is invalid
+ *
+ * @example
+ * formatShortDate('2024-01-15T20:30:00Z')
+ * // "Jan 15, 2024" (in UTC)
+ *
+ * formatShortDate('2024-01-15T20:30:00Z', 'America/Los_Angeles')
+ * // "Jan 15, 2024" (in LA timezone)
+ */
+export declare function formatShortDate(utcIso: ISODateString, timezone?: TimezoneId): string;
+/**
+ * Formats a time range with clean formatting (omits :00 minutes).
+ * More compact display for times on the hour.
+ *
+ * @param startUtc - Start time as UTC ISO string
+ * @param endUtc - End time as UTC ISO string
+ * @param timezone - IANA timezone ID
+ * @returns Formatted time range (e.g., "8 PM - 11 PM" or "8:30 PM - 11 PM")
+ * @throws {DateTimeError} If timezone or ISO strings are invalid
+ *
+ * @example
+ * formatCleanTimeRange(
+ *   '2023-12-25T03:00:00Z',
+ *   '2023-12-25T06:00:00Z',
+ *   'America/Los_Angeles'
+ * )
+ * // "7 PM - 10 PM" (times are on the hour, so no :00)
+ *
+ * formatCleanTimeRange(
+ *   '2023-12-25T03:30:00Z',
+ *   '2023-12-25T06:00:00Z',
+ *   'America/Los_Angeles'
+ * )
+ * // "7:30 PM - 10 PM"
+ */
+export declare function formatCleanTimeRange(startUtc: ISODateString, endUtc: ISODateString, timezone: TimezoneId): string;
 //# sourceMappingURL=format.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/lib/datetime/format.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,OAAO,KAAK,EACV,SAAS,EACT,aAAa,EACb,aAAa,EACb,UAAU,EACX,MAAM,SAAS,CAAC;AA4CjB;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,CAMR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,CAOR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,CAiBR;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAIR;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CA4BR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAoDR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,SAAS,CASX;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAkBR;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,EACpB,KAAK,GAAE,OAAc,GACpB,MAAM,CAMR;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,EACpB,KAAK,GAAE,OAAc,GACpB,MAAM,CAMR;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAGR;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAGR"}
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/lib/datetime/format.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,OAAO,KAAK,EACV,SAAS,EACT,aAAa,EACb,aAAa,EACb,UAAU,EACX,MAAM,SAAS,CAAC;AA4CjB;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,CAMR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,CAOR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,CAiBR;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAIR;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CA4BR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAoDR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,SAAS,CASX;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAkBR;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,EACpB,KAAK,GAAE,OAAc,GACpB,MAAM,CAMR;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,EACpB,KAAK,GAAE,OAAc,GACpB,MAAM,CAMR;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAGR;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAGR;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CACrB,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,OAAO,CAST;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,QAAQ,GAAE,UAAkB,GAC3B,MAAM,CAGR;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,aAAa,EACvB,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,UAAU,GACnB,MAAM,CAgBR"}