@getmicdrop/svelte-components 5.5.4 → 5.5.5

package/dist/calendar/ShowTimeCard/ShowTimeCard.spec.d.ts

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

package/dist/calendar/ShowTimeCard/ShowTimeCard.spec.d.ts.map

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

package/dist/calendar/ShowTimeCard/ShowTimeCard.spec.js

@@ -0,0 +1,241 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, cleanup, fireEvent } from '@testing-library/svelte';
+import ShowTimeCard from './ShowTimeCard.svelte';
+
+describe('ShowTimeCard Component', () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe('rendering', () => {
+    it('renders a button element', () => {
+      render(ShowTimeCard);
+      const button = screen.getByRole('button');
+      expect(button).toBeInTheDocument();
+    });
+
+    it('displays the day', () => {
+      render(ShowTimeCard, { props: { day: 'Monday' } });
+      expect(screen.getByText('Monday')).toBeInTheDocument();
+    });
+
+    it('displays formatted date', () => {
+      render(ShowTimeCard, { props: { date: '2024-03-15' } });
+      // Date may vary by timezone, just check the format
+      const button = screen.getByRole('button');
+      expect(button.textContent).toMatch(/Mar 1[45]/);
+    });
+
+    it('displays formatted time', () => {
+      render(ShowTimeCard, { props: { time: '19:30:00' } });
+      expect(screen.getByText('7:30 PM')).toBeInTheDocument();
+    });
+
+    it('handles empty values gracefully', () => {
+      const { container } = render(ShowTimeCard);
+      expect(container.querySelector('[role="button"]')).toBeInTheDocument();
+    });
+  });
+
+  describe('date formatting', () => {
+    it('formats valid date string', () => {
+      render(ShowTimeCard, { props: { date: '2024-12-25' } });
+      // Date may show as Dec 24 or Dec 25 depending on timezone
+      const button = screen.getByRole('button');
+      expect(button.textContent).toMatch(/Dec 2[45]/);
+    });
+
+    it('returns original string for invalid date', () => {
+      render(ShowTimeCard, { props: { date: 'invalid-date' } });
+      expect(screen.getByText('invalid-date')).toBeInTheDocument();
+    });
+
+    it('handles empty date', () => {
+      render(ShowTimeCard, { props: { date: '' } });
+      const button = screen.getByRole('button');
+      expect(button).toBeInTheDocument();
+    });
+  });
+
+  describe('time formatting', () => {
+    it('formats morning time', () => {
+      render(ShowTimeCard, { props: { time: '09:00:00' } });
+      expect(screen.getByText('9:00 AM')).toBeInTheDocument();
+    });
+
+    it('formats afternoon time', () => {
+      render(ShowTimeCard, { props: { time: '14:30:00' } });
+      expect(screen.getByText('2:30 PM')).toBeInTheDocument();
+    });
+
+    it('formats midnight', () => {
+      render(ShowTimeCard, { props: { time: '00:00:00' } });
+      expect(screen.getByText('12:00 AM')).toBeInTheDocument();
+    });
+
+    it('formats noon', () => {
+      render(ShowTimeCard, { props: { time: '12:00:00' } });
+      expect(screen.getByText('12:00 PM')).toBeInTheDocument();
+    });
+
+    it('returns original string for invalid time', () => {
+      render(ShowTimeCard, { props: { time: 'invalid' } });
+      expect(screen.getByText('invalid')).toBeInTheDocument();
+    });
+
+    it('handles empty time', () => {
+      render(ShowTimeCard, { props: { time: '' } });
+      const button = screen.getByRole('button');
+      expect(button).toBeInTheDocument();
+    });
+  });
+
+  describe('selection state', () => {
+    it('is not selected by default', () => {
+      render(ShowTimeCard);
+      const button = screen.getByRole('button');
+      expect(button).toHaveAttribute('aria-pressed', 'false');
+    });
+
+    it('shows selected state when isSelected is true', () => {
+      render(ShowTimeCard, { props: { isSelected: true } });
+      const button = screen.getByRole('button');
+      expect(button).toHaveAttribute('aria-pressed', 'true');
+    });
+
+    it('applies selected border class', () => {
+      const { container } = render(ShowTimeCard, { props: { isSelected: true } });
+      const card = container.querySelector('[role="button"]');
+      expect(card.className).toContain('border-blue-700');
+    });
+
+    it('applies unselected border class when not selected', () => {
+      const { container } = render(ShowTimeCard, { props: { isSelected: false } });
+      const card = container.querySelector('[role="button"]');
+      expect(card.className).toContain('border-gray-200');
+    });
+  });
+
+  describe('click handling', () => {
+    it('calls onselect when clicked', async () => {
+      const onselect = vi.fn();
+      render(ShowTimeCard, { props: { onselect, date: '2024-03-15' } });
+
+      const button = screen.getByRole('button');
+      await fireEvent.click(button);
+
+      expect(onselect).toHaveBeenCalledWith({ date: '2024-03-15' });
+    });
+
+    it('does not throw when onselect is not provided', async () => {
+      render(ShowTimeCard);
+      const button = screen.getByRole('button');
+
+      await expect(fireEvent.click(button)).resolves.not.toThrow();
+    });
+  });
+
+  describe('keyboard handling', () => {
+    it('calls onselect when Enter is pressed', async () => {
+      const onselect = vi.fn();
+      render(ShowTimeCard, { props: { onselect, date: '2024-03-15' } });
+
+      const button = screen.getByRole('button');
+      await fireEvent.keyDown(button, { key: 'Enter' });
+
+      expect(onselect).toHaveBeenCalledWith({ date: '2024-03-15' });
+    });
+
+    it('calls onselect when Space is pressed', async () => {
+      const onselect = vi.fn();
+      render(ShowTimeCard, { props: { onselect, date: '2024-03-15' } });
+
+      const button = screen.getByRole('button');
+      await fireEvent.keyDown(button, { key: ' ' });
+
+      expect(onselect).toHaveBeenCalledWith({ date: '2024-03-15' });
+    });
+
+    it('does not call onselect for other keys', async () => {
+      const onselect = vi.fn();
+      render(ShowTimeCard, { props: { onselect, date: '2024-03-15' } });
+
+      const button = screen.getByRole('button');
+      await fireEvent.keyDown(button, { key: 'Tab' });
+
+      expect(onselect).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('accessibility', () => {
+    it('has aria-label with day, date, and time', () => {
+      render(ShowTimeCard, {
+        props: { day: 'Monday', date: '2024-03-15', time: '19:30:00' }
+      });
+
+      const button = screen.getByRole('button');
+      const ariaLabel = button.getAttribute('aria-label');
+      expect(ariaLabel).toContain('Monday');
+      expect(ariaLabel).toContain('Mar');
+      expect(ariaLabel).toContain('7:30 PM');
+    });
+
+    it('includes selected in aria-label when selected', () => {
+      render(ShowTimeCard, {
+        props: { day: 'Monday', date: '2024-03-15', time: '19:30:00', isSelected: true }
+      });
+
+      const button = screen.getByRole('button');
+      const ariaLabel = button.getAttribute('aria-label');
+      expect(ariaLabel).toContain('selected');
+    });
+
+    it('is focusable', () => {
+      render(ShowTimeCard);
+      const button = screen.getByRole('button');
+      expect(button).toHaveAttribute('tabindex', '0');
+    });
+  });
+
+  describe('styling', () => {
+    it('has correct base classes', () => {
+      const { container } = render(ShowTimeCard);
+      const card = container.querySelector('[role="button"]');
+      expect(card).toHaveClass('w-full', 'h-28', 'rounded-lg');
+    });
+
+    it('has flex layout', () => {
+      const { container } = render(ShowTimeCard);
+      const card = container.querySelector('[role="button"]');
+      expect(card).toHaveClass('flex', 'flex-col', 'justify-center', 'items-center');
+    });
+
+    it('has cursor pointer', () => {
+      const { container } = render(ShowTimeCard);
+      const card = container.querySelector('[role="button"]');
+      expect(card).toHaveClass('cursor-pointer');
+    });
+
+    it('has transition', () => {
+      const { container } = render(ShowTimeCard);
+      const card = container.querySelector('[role="button"]');
+      expect(card).toHaveClass('transition-colors');
+    });
+
+    it('includes dark mode background', () => {
+      const { container } = render(ShowTimeCard);
+      const card = container.querySelector('[role="button"]');
+      expect(card.className).toContain('dark:bg-gray-800');
+    });
+
+    it('applies selected text color when selected', () => {
+      const { container } = render(ShowTimeCard, {
+        props: { date: '2024-03-15', isSelected: true }
+      });
+      // Find the date span (middle one) which gets the selected color
+      const spans = container.querySelectorAll('span');
+      const dateSpan = spans[1]; // Second span is the date
+      expect(dateSpan.className).toContain('text-blue-700');
+    });
+  });
+});

package/dist/components/Layout/Section.spec.d.ts

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

package/dist/components/Layout/Section.spec.d.ts.map

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

package/dist/components/Layout/Section.spec.js

@@ -0,0 +1,149 @@
+import { render, screen } from '@testing-library/svelte';
+import { expect, describe, test } from 'vitest';
+import Section from './Section.svelte';
+
+describe('Section Component', () => {
+  test('renders a section element', () => {
+    const { container } = render(Section);
+    expect(container.querySelector('section')).toBeInTheDocument();
+  });
+
+  test('applies custom className', () => {
+    const { container } = render(Section, { props: { class: 'custom-section' } });
+    const section = container.querySelector('section');
+    expect(section).toHaveClass('custom-section');
+  });
+});
+
+describe('Section Title', () => {
+  test('no title renders no h2', () => {
+    const { container } = render(Section);
+    expect(container.querySelector('h2')).not.toBeInTheDocument();
+  });
+
+  test('title prop renders h2', () => {
+    render(Section, { props: { title: 'Recent Orders' } });
+    expect(screen.getByText('Recent Orders')).toBeInTheDocument();
+  });
+
+  test('title is in h2 element', () => {
+    const { container } = render(Section, { props: { title: 'Test Title' } });
+    const h2 = container.querySelector('h2');
+    expect(h2).toBeInTheDocument();
+    expect(h2).toHaveTextContent('Test Title');
+  });
+
+  test('title adds aria-label to section', () => {
+    const { container } = render(Section, { props: { title: 'Orders Section' } });
+    const section = container.querySelector('section');
+    expect(section).toHaveAttribute('aria-label', 'Orders Section');
+  });
+
+  test('no aria-label when no title', () => {
+    const { container } = render(Section);
+    const section = container.querySelector('section');
+    expect(section).not.toHaveAttribute('aria-label');
+  });
+});
+
+describe('Section Title Size', () => {
+  test('default titleSize=md applies h3 typography', () => {
+    const { container } = render(Section, { props: { title: 'Test' } });
+    const h2 = container.querySelector('h2');
+    // Check that h2 exists and has some styling
+    expect(h2).toBeInTheDocument();
+  });
+
+  test('titleSize=sm applies smaller typography', () => {
+    const { container } = render(Section, { props: { title: 'Test', titleSize: 'sm' } });
+    const h2 = container.querySelector('h2');
+    expect(h2).toBeInTheDocument();
+  });
+
+  test('titleSize=lg applies larger typography', () => {
+    const { container } = render(Section, { props: { title: 'Test', titleSize: 'lg' } });
+    const h2 = container.querySelector('h2');
+    expect(h2).toBeInTheDocument();
+  });
+});
+
+describe('Section Title Class', () => {
+  test('titleClass applies to h2', () => {
+    const { container } = render(Section, { props: { title: 'Test', titleClass: 'custom-title' } });
+    const h2 = container.querySelector('h2');
+    expect(h2).toHaveClass('custom-title');
+  });
+});
+
+describe('Section Gap', () => {
+  test('gap applies when title present', () => {
+    const { container } = render(Section, { props: { title: 'Test', gap: '4' } });
+    const section = container.querySelector('section');
+    expect(section).toHaveClass('space-y-4');
+  });
+
+  test('gap=2 applies space-y-2', () => {
+    const { container } = render(Section, { props: { title: 'Test', gap: '2' } });
+    const section = container.querySelector('section');
+    expect(section).toHaveClass('space-y-2');
+  });
+
+  test('gap=3 applies space-y-3', () => {
+    const { container } = render(Section, { props: { title: 'Test', gap: '3' } });
+    const section = container.querySelector('section');
+    expect(section).toHaveClass('space-y-3');
+  });
+
+  test('gap=6 applies space-y-6', () => {
+    const { container } = render(Section, { props: { title: 'Test', gap: '6' } });
+    const section = container.querySelector('section');
+    expect(section).toHaveClass('space-y-6');
+  });
+
+  test('no gap class when no title', () => {
+    const { container } = render(Section);
+    const section = container.querySelector('section');
+    expect(section).not.toHaveClass('space-y-4');
+    expect(section).not.toHaveClass('space-y-2');
+  });
+});
+
+describe('Section Combinations', () => {
+  test('title and titleSize', () => {
+    render(Section, { props: { title: 'Products', titleSize: 'lg' } });
+    expect(screen.getByText('Products')).toBeInTheDocument();
+  });
+
+  test('title with titleClass and custom class', () => {
+    const { container } = render(Section, {
+      props: {
+        title: 'Orders',
+        titleClass: 'text-blue-500',
+        class: 'my-section'
+      }
+    });
+    const section = container.querySelector('section');
+    const h2 = container.querySelector('h2');
+    expect(section).toHaveClass('my-section');
+    expect(h2).toHaveClass('text-blue-500');
+  });
+
+  test('all props together', () => {
+    const { container } = render(Section, {
+      props: {
+        title: 'Statistics',
+        titleSize: 'lg',
+        gap: '6',
+        class: 'bg-white',
+        titleClass: 'font-bold'
+      }
+    });
+    const section = container.querySelector('section');
+    expect(section).toHaveClass('bg-white');
+    expect(section).toHaveClass('space-y-6');
+    expect(section).toHaveAttribute('aria-label', 'Statistics');
+    const h2 = container.querySelector('h2');
+    expect(h2).toHaveClass('font-bold');
+    expect(h2).toHaveTextContent('Statistics');
+  });
+});

package/dist/components/Layout/Sidebar.spec.d.ts

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

package/dist/components/Layout/Sidebar.spec.d.ts.map

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

package/dist/components/Layout/Sidebar.spec.js

@@ -0,0 +1,186 @@
+import { render } from '@testing-library/svelte';
+import { expect, describe, test } from 'vitest';
+import Sidebar from './Sidebar.svelte';
+
+describe('Sidebar Component', () => {
+  test('renders a grid container', () => {
+    const { container } = render(Sidebar);
+    const grid = container.querySelector('div');
+    expect(grid).toHaveClass('grid');
+  });
+
+  test('has lg:grid-cols-12', () => {
+    const { container } = render(Sidebar);
+    const grid = container.querySelector('div');
+    expect(grid).toHaveClass('lg:grid-cols-12');
+  });
+
+  test('applies custom className', () => {
+    const { container } = render(Sidebar, { props: { class: 'custom-sidebar' } });
+    const grid = container.querySelector('div');
+    expect(grid).toHaveClass('custom-sidebar');
+  });
+
+  test('renders main content area', () => {
+    const { container } = render(Sidebar);
+    const divs = container.querySelectorAll('div');
+    // Main container + main content div + aside
+    expect(divs.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test('renders aside element', () => {
+    const { container } = render(Sidebar);
+    expect(container.querySelector('aside')).toBeInTheDocument();
+  });
+});
+
+describe('Sidebar Stack On Mobile', () => {
+  test('default stackOnMobile=true applies grid-cols-1', () => {
+    const { container } = render(Sidebar);
+    const grid = container.querySelector('div');
+    expect(grid).toHaveClass('grid-cols-1');
+  });
+
+  test('stackOnMobile=false does not apply grid-cols-1', () => {
+    const { container } = render(Sidebar, { props: { stackOnMobile: false } });
+    const grid = container.querySelector('div');
+    expect(grid).not.toHaveClass('grid-cols-1');
+  });
+});
+
+describe('Sidebar Width', () => {
+  test('default sidebarWidth=medium applies lg:col-span-4 to sidebar', () => {
+    const { container } = render(Sidebar);
+    const aside = container.querySelector('aside');
+    expect(aside).toHaveClass('lg:col-span-4');
+  });
+
+  test('default sidebarWidth=medium applies lg:col-span-8 to main', () => {
+    const { container } = render(Sidebar);
+    const grid = container.querySelector('.grid');
+    const mainDiv = grid.querySelector('div.col-span-1');
+    expect(mainDiv).toHaveClass('lg:col-span-8');
+  });
+
+  test('sidebarWidth=narrow applies lg:col-span-3 to sidebar', () => {
+    const { container } = render(Sidebar, { props: { sidebarWidth: 'narrow' } });
+    const aside = container.querySelector('aside');
+    expect(aside).toHaveClass('lg:col-span-3');
+  });
+
+  test('sidebarWidth=narrow applies lg:col-span-9 to main', () => {
+    const { container } = render(Sidebar, { props: { sidebarWidth: 'narrow' } });
+    const grid = container.querySelector('.grid');
+    const mainDiv = grid.querySelector('div.col-span-1');
+    expect(mainDiv).toHaveClass('lg:col-span-9');
+  });
+
+  test('sidebarWidth=wide applies lg:col-span-5 to sidebar', () => {
+    const { container } = render(Sidebar, { props: { sidebarWidth: 'wide' } });
+    const aside = container.querySelector('aside');
+    expect(aside).toHaveClass('lg:col-span-5');
+  });
+
+  test('sidebarWidth=wide applies lg:col-span-7 to main', () => {
+    const { container } = render(Sidebar, { props: { sidebarWidth: 'wide' } });
+    const grid = container.querySelector('.grid');
+    const mainDiv = grid.querySelector('div.col-span-1');
+    expect(mainDiv).toHaveClass('lg:col-span-7');
+  });
+});
+
+describe('Sidebar Position', () => {
+  test('default sidebarPosition=right applies lg:order-2 to sidebar', () => {
+    const { container } = render(Sidebar);
+    const aside = container.querySelector('aside');
+    expect(aside).toHaveClass('lg:order-2');
+  });
+
+  test('default sidebarPosition=right applies lg:order-1 to main', () => {
+    const { container } = render(Sidebar);
+    const grid = container.querySelector('.grid');
+    const mainDiv = grid.querySelector('div.col-span-1');
+    expect(mainDiv).toHaveClass('lg:order-1');
+  });
+
+  test('sidebarPosition=left applies lg:order-1 to sidebar', () => {
+    const { container } = render(Sidebar, { props: { sidebarPosition: 'left' } });
+    const aside = container.querySelector('aside');
+    expect(aside).toHaveClass('lg:order-1');
+  });
+
+  test('sidebarPosition=left applies lg:order-2 to main', () => {
+    const { container } = render(Sidebar, { props: { sidebarPosition: 'left' } });
+    const grid = container.querySelector('.grid');
+    const mainDiv = grid.querySelector('div.col-span-1');
+    expect(mainDiv).toHaveClass('lg:order-2');
+  });
+});
+
+describe('Sidebar Gap', () => {
+  test('default gap=6 applies gap-6', () => {
+    const { container } = render(Sidebar);
+    const grid = container.querySelector('div');
+    expect(grid).toHaveClass('gap-6');
+  });
+
+  test('gap=4 applies gap-4', () => {
+    const { container } = render(Sidebar, { props: { gap: '4' } });
+    const grid = container.querySelector('div');
+    expect(grid).toHaveClass('gap-4');
+  });
+
+  test('gap=8 applies gap-8', () => {
+    const { container } = render(Sidebar, { props: { gap: '8' } });
+    const grid = container.querySelector('div');
+    expect(grid).toHaveClass('gap-8');
+  });
+});
+
+describe('Sidebar Combinations', () => {
+  test('narrow left sidebar', () => {
+    const { container } = render(Sidebar, {
+      props: { sidebarWidth: 'narrow', sidebarPosition: 'left' }
+    });
+    const aside = container.querySelector('aside');
+    expect(aside).toHaveClass('lg:col-span-3');
+    expect(aside).toHaveClass('lg:order-1');
+  });
+
+  test('wide right sidebar with gap', () => {
+    const { container } = render(Sidebar, {
+      props: { sidebarWidth: 'wide', gap: '8' }
+    });
+    const grid = container.querySelector('div');
+    const aside = container.querySelector('aside');
+    expect(grid).toHaveClass('gap-8');
+    expect(aside).toHaveClass('lg:col-span-5');
+  });
+
+  test('all props together', () => {
+    const { container } = render(Sidebar, {
+      props: {
+        sidebarWidth: 'wide',
+        sidebarPosition: 'left',
+        gap: '8',
+        stackOnMobile: false,
+        class: 'custom-layout'
+      }
+    });
+    const grid = container.querySelector('.grid');
+    const aside = container.querySelector('aside');
+    const mainDiv = grid.querySelector('div.col-span-1');
+
+    expect(grid).toHaveClass('grid');
+    expect(grid).toHaveClass('lg:grid-cols-12');
+    expect(grid).toHaveClass('gap-8');
+    expect(grid).toHaveClass('custom-layout');
+    expect(grid).not.toHaveClass('grid-cols-1');
+
+    expect(aside).toHaveClass('lg:col-span-5');
+    expect(aside).toHaveClass('lg:order-1');
+
+    expect(mainDiv).toHaveClass('lg:col-span-7');
+    expect(mainDiv).toHaveClass('lg:order-2');
+  });
+});

package/dist/components/Layout/Stack.spec.js

@@ -1,4 +1,4 @@
-import { render, screen } from '@testing-library/svelte';
+import { render } from '@testing-library/svelte';
 import { expect, describe, test } from 'vitest';
 import Stack from './Stack.svelte';
 describe('Stack Component', () => {
@@ -25,9 +25,9 @@ describe('Stack Component', () => {
         });
     });
     describe('Gap - Semantic Names', () => {
-        test('tight gap (4px)', () => {
+        test('tight gap (16px)', () => {
             const { container } = render(Stack, { gap: 'tight' });
-            expect(container.querySelector('div')).toHaveClass('gap-1');
+            expect(container.querySelector('div')).toHaveClass('gap-4');
         });
         test('compact gap (6px)', () => {
             const { container } = render(Stack, { gap: 'compact' });

package/dist/constants/formOptions.spec.js

@@ -6,8 +6,8 @@ describe('formOptions', () => {
             expect(GENDER_OPTIONS).toBeDefined();
             expect(Array.isArray(GENDER_OPTIONS)).toBe(true);
         });
-        it('has three options', () => {
-            expect(GENDER_OPTIONS.length).toBe(3);
+        it('has five options (including empty placeholder and rather not say)', () => {
+            expect(GENDER_OPTIONS.length).toBe(5);
         });
         it('contains Male option with value 1', () => {
             const male = GENDER_OPTIONS.find(opt => opt.name === 'Male');
@@ -19,17 +19,21 @@ describe('formOptions', () => {
             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');
+        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('contains Rather not say option with value 4', () => {
+            const ratherNotSay = GENDER_OPTIONS.find(opt => opt.name === 'Rather not say');
+            expect(ratherNotSay).toBeDefined();
+            expect(ratherNotSay.value).toBe(4);
+        });
         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');
             });
         });
     });

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

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { formatCleanTimeRange, formatDateRange, formatDayOfWeek, formatEventDate, formatEventDateTime, formatEventTime, formatHour, formatMonth, formatNotificationTime, formatRelativeTime, formatTimeRange, getDateInTimezone, getDateParts, getHourInTimezone, isToday, } from '../format';
-import { DateTimeError, DateTimeErrorCode } from '../types';
+import { DateTimeError } from '../types';
 describe('format utilities', () => {
     describe('formatEventTime', () => {
         it('formats time in specified timezone', () => {

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

@@ -1,6 +1,6 @@
 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';
+import { DateTimeError } from '../types';
 describe('parse utilities', () => {
     describe('parseLocalToUTC', () => {
         it('converts local datetime to UTC', () => {