@getmicdrop/svelte-components 5.9.6 → 5.10.1

package/dist/services/EventService.spec.js

@@ -1,217 +1,217 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// Create mock functions we'll spy on
-const mockEvents = [
-  { ID: 1, startDateTime: '2025-01-15T20:00:00', title: 'Comedy Night' },
-  { ID: 2, startDateTime: '2025-01-15T21:00:00', title: 'Open Mic' },
-  { ID: 3, startDateTime: '2025-02-10T19:00:00', title: 'Improv Show' },
-];
-
-import {
-  fetchEventsFromAPI,
-  fetchEventsForMonth,
-  fetchEventsForWeek,
-  fetchEventsForDay,
-} from './EventService';
-
-describe('EventService', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    global.fetch = vi.fn();
-  });
-
-  describe('fetchEventsFromAPI', () => {
-    it('fetches events from the API', async () => {
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockEvents),
-      });
-
-      const events = await fetchEventsFromAPI();
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        'https://get-micdrop.com/api/public/getEventsForVenue'
-      );
-      expect(events).toHaveLength(3);
-    });
-
-    it('transforms event data correctly', async () => {
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve([mockEvents[0]]),
-      });
-
-      const events = await fetchEventsFromAPI();
-
-      expect(events[0]).toEqual({
-        id: 1,
-        date: '2025-01-15T20:00:00',
-        title: 'Comedy Night',
-      });
-    });
-
-    it('returns empty array on failed response', async () => {
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      global.fetch.mockResolvedValue({
-        ok: false,
-        status: 500,
-      });
-
-      const events = await fetchEventsFromAPI();
-
-      expect(events).toEqual([]);
-      consoleSpy.mockRestore();
-    });
-
-    it('returns empty array on network error', async () => {
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      global.fetch.mockRejectedValue(new Error('Network error'));
-
-      const events = await fetchEventsFromAPI();
-
-      expect(events).toEqual([]);
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('fetchEventsForMonth', () => {
-    it('filters events by year and month', async () => {
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockEvents),
-      });
-
-      const events = await fetchEventsForMonth(2025, 1);
-
-      expect(events.length).toBe(2);
-      expect(events[0].title).toBe('Comedy Night');
-      expect(events[1].title).toBe('Open Mic');
-    }, 10000);
-
-    it('returns empty for month with no events', async () => {
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockEvents),
-      });
-
-      const events = await fetchEventsForMonth(2025, 3);
-
-      expect(events).toEqual([]);
-    }, 10000);
-
-    it('pads single digit months correctly', async () => {
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockEvents),
-      });
-
-      const events = await fetchEventsForMonth(2025, 2);
-
-      expect(events.length).toBe(1);
-      expect(events[0].title).toBe('Improv Show');
-    }, 10000);
-
-    it('handles double digit months', async () => {
-      const decemberEvents = [
-        { ID: 4, startDateTime: '2025-12-25T20:00:00', title: 'Holiday Show' },
-      ];
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(decemberEvents),
-      });
-
-      const events = await fetchEventsForMonth(2025, 12);
-
-      expect(events.length).toBe(1);
-    }, 10000);
-  });
-
-  describe('fetchEventsForWeek', () => {
-    it('filters events within the week', async () => {
-      // Events on Jan 13-14, 2025 (Monday-Tuesday of that week)
-      const weekEvents = [
-        { ID: 1, startDateTime: '2025-01-13T20:00:00', title: 'Monday Show' },
-        { ID: 2, startDateTime: '2025-01-14T19:00:00', title: 'Tuesday Show' },
-        { ID: 3, startDateTime: '2025-01-20T20:00:00', title: 'Next Week Show' },
-      ];
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(weekEvents),
-      });
-
-      // Jan 15, 2025 is a Wednesday
-      const date = new Date('2025-01-15');
-      const events = await fetchEventsForWeek(date);
-
-      // Should include Monday and Tuesday shows (same week)
-      expect(events.length).toBe(2);
-    }, 10000);
-
-    it('uses Monday as week start', async () => {
-      const events = [
-        { ID: 1, startDateTime: '2025-01-12T20:00:00', title: 'Sunday Show' },
-        { ID: 2, startDateTime: '2025-01-13T20:00:00', title: 'Monday Show' },
-      ];
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(events),
-      });
-
-      // Pass a date in the week starting Jan 13
-      const date = new Date('2025-01-15');
-      const result = await fetchEventsForWeek(date);
-
-      // Sunday should be excluded, Monday included
-      expect(result.some((e) => e.title === 'Monday Show')).toBe(true);
-    }, 10000);
-  });
-
-  describe('fetchEventsForDay', () => {
-    it('filters events for specific day', async () => {
-      // Use Z suffix for UTC dates to avoid timezone issues
-      const dayEvents = [
-        { ID: 1, startDateTime: '2025-01-15T14:00:00Z', title: 'Afternoon Show' },
-        { ID: 2, startDateTime: '2025-01-15T20:00:00Z', title: 'Evening Show' },
-        { ID: 3, startDateTime: '2025-01-16T20:00:00Z', title: 'Next Day Show' },
-      ];
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(dayEvents),
-      });
-
-      const date = new Date(Date.UTC(2025, 0, 15)); // Jan 15, 2025 UTC
-      const events = await fetchEventsForDay(date);
-
-      expect(events.length).toBe(2);
-      expect(events[0].title).toBe('Afternoon Show');
-      expect(events[1].title).toBe('Evening Show');
-    }, 10000);
-
-    it('returns empty array for day with no events', async () => {
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockEvents),
-      });
-
-      const date = new Date(Date.UTC(2025, 0, 20)); // Jan 20, 2025
-      const events = await fetchEventsForDay(date);
-
-      expect(events).toEqual([]);
-    }, 10000);
-
-    it('matches dates using UTC methods', async () => {
-      const dayEvents = [
-        { ID: 1, startDateTime: '2025-06-15T23:00:00Z', title: 'Late Show' },
-      ];
-      global.fetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(dayEvents),
-      });
-
-      const date = new Date(Date.UTC(2025, 5, 15)); // June 15, 2025 UTC
-      const events = await fetchEventsForDay(date);
-
-      expect(events.length).toBe(1);
-    }, 10000);
-  });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Create mock functions we'll spy on
+const mockEvents = [
+  { ID: 1, startDateTime: '2025-01-15T20:00:00', title: 'Comedy Night' },
+  { ID: 2, startDateTime: '2025-01-15T21:00:00', title: 'Open Mic' },
+  { ID: 3, startDateTime: '2025-02-10T19:00:00', title: 'Improv Show' },
+];
+
+import {
+  fetchEventsFromAPI,
+  fetchEventsForMonth,
+  fetchEventsForWeek,
+  fetchEventsForDay,
+} from './EventService';
+
+describe('EventService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    global.fetch = vi.fn();
+  });
+
+  describe('fetchEventsFromAPI', () => {
+    it('fetches events from the API', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockEvents),
+      });
+
+      const events = await fetchEventsFromAPI();
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://get-micdrop.com/api/public/getEventsForVenue'
+      );
+      expect(events).toHaveLength(3);
+    });
+
+    it('transforms event data correctly', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve([mockEvents[0]]),
+      });
+
+      const events = await fetchEventsFromAPI();
+
+      expect(events[0]).toEqual({
+        id: 1,
+        date: '2025-01-15T20:00:00',
+        title: 'Comedy Night',
+      });
+    });
+
+    it('returns empty array on failed response', async () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      global.fetch.mockResolvedValue({
+        ok: false,
+        status: 500,
+      });
+
+      const events = await fetchEventsFromAPI();
+
+      expect(events).toEqual([]);
+      consoleSpy.mockRestore();
+    });
+
+    it('returns empty array on network error', async () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      global.fetch.mockRejectedValue(new Error('Network error'));
+
+      const events = await fetchEventsFromAPI();
+
+      expect(events).toEqual([]);
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('fetchEventsForMonth', () => {
+    it('filters events by year and month', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockEvents),
+      });
+
+      const events = await fetchEventsForMonth(2025, 1);
+
+      expect(events.length).toBe(2);
+      expect(events[0].title).toBe('Comedy Night');
+      expect(events[1].title).toBe('Open Mic');
+    }, 10000);
+
+    it('returns empty for month with no events', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockEvents),
+      });
+
+      const events = await fetchEventsForMonth(2025, 3);
+
+      expect(events).toEqual([]);
+    }, 10000);
+
+    it('pads single digit months correctly', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockEvents),
+      });
+
+      const events = await fetchEventsForMonth(2025, 2);
+
+      expect(events.length).toBe(1);
+      expect(events[0].title).toBe('Improv Show');
+    }, 10000);
+
+    it('handles double digit months', async () => {
+      const decemberEvents = [
+        { ID: 4, startDateTime: '2025-12-25T20:00:00', title: 'Holiday Show' },
+      ];
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(decemberEvents),
+      });
+
+      const events = await fetchEventsForMonth(2025, 12);
+
+      expect(events.length).toBe(1);
+    }, 10000);
+  });
+
+  describe('fetchEventsForWeek', () => {
+    it('filters events within the week', async () => {
+      // Events on Jan 13-14, 2025 (Monday-Tuesday of that week)
+      const weekEvents = [
+        { ID: 1, startDateTime: '2025-01-13T20:00:00', title: 'Monday Show' },
+        { ID: 2, startDateTime: '2025-01-14T19:00:00', title: 'Tuesday Show' },
+        { ID: 3, startDateTime: '2025-01-20T20:00:00', title: 'Next Week Show' },
+      ];
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(weekEvents),
+      });
+
+      // Jan 15, 2025 is a Wednesday
+      const date = new Date('2025-01-15');
+      const events = await fetchEventsForWeek(date);
+
+      // Should include Monday and Tuesday shows (same week)
+      expect(events.length).toBe(2);
+    }, 10000);
+
+    it('uses Monday as week start', async () => {
+      const events = [
+        { ID: 1, startDateTime: '2025-01-12T20:00:00', title: 'Sunday Show' },
+        { ID: 2, startDateTime: '2025-01-13T20:00:00', title: 'Monday Show' },
+      ];
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(events),
+      });
+
+      // Pass a date in the week starting Jan 13
+      const date = new Date('2025-01-15');
+      const result = await fetchEventsForWeek(date);
+
+      // Sunday should be excluded, Monday included
+      expect(result.some((e) => e.title === 'Monday Show')).toBe(true);
+    }, 10000);
+  });
+
+  describe('fetchEventsForDay', () => {
+    it('filters events for specific day', async () => {
+      // Use Z suffix for UTC dates to avoid timezone issues
+      const dayEvents = [
+        { ID: 1, startDateTime: '2025-01-15T14:00:00Z', title: 'Afternoon Show' },
+        { ID: 2, startDateTime: '2025-01-15T20:00:00Z', title: 'Evening Show' },
+        { ID: 3, startDateTime: '2025-01-16T20:00:00Z', title: 'Next Day Show' },
+      ];
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(dayEvents),
+      });
+
+      const date = new Date(Date.UTC(2025, 0, 15)); // Jan 15, 2025 UTC
+      const events = await fetchEventsForDay(date);
+
+      expect(events.length).toBe(2);
+      expect(events[0].title).toBe('Afternoon Show');
+      expect(events[1].title).toBe('Evening Show');
+    }, 10000);
+
+    it('returns empty array for day with no events', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockEvents),
+      });
+
+      const date = new Date(Date.UTC(2025, 0, 20)); // Jan 20, 2025
+      const events = await fetchEventsForDay(date);
+
+      expect(events).toEqual([]);
+    }, 10000);
+
+    it('matches dates using UTC methods', async () => {
+      const dayEvents = [
+        { ID: 1, startDateTime: '2025-06-15T23:00:00Z', title: 'Late Show' },
+      ];
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(dayEvents),
+      });
+
+      const date = new Date(Date.UTC(2025, 5, 15)); // June 15, 2025 UTC
+      const events = await fetchEventsForDay(date);
+
+      expect(events.length).toBe(1);
+    }, 10000);
+  });
+});

package/dist/services/ShowService.d.ts

@@ -1,47 +1,47 @@
-/**
- * Accept an event performer invitation
- * @param {string|number} inviteId - The invitation ID
- * @param {string} message - Optional message to include
- * @returns {Promise<{ok: boolean, result?: any}>}
- */
-export function acceptInvite(inviteId: string | number, message?: string): Promise<{
-    ok: boolean;
-    result?: any;
-}>;
-/**
- * Decline an event performer invitation
- * @param {string|number} inviteId - The invitation ID
- * @param {string} message - Optional message to include
- * @returns {Promise<{ok: boolean, result?: any}>}
- */
-export function declineInvite(inviteId: string | number, message?: string): Promise<{
-    ok: boolean;
-    result?: any;
-}>;
-/**
- * Cancel an event performer invitation
- * @param {string|number} inviteId - The invitation ID
- * @param {string} message - Optional message to include
- * @returns {Promise<{ok: boolean, result?: any}>}
- */
-export function cancelInvite(inviteId: string | number, message?: string): Promise<{
-    ok: boolean;
-    result?: any;
-}>;
-/**
- * Send a message to a venue
- * @param {string|number} inviteId - The invitation/event ID
- * @param {string} message - The message to send
- * @returns {Promise<{ok: boolean, result?: any}>}
- */
-export function sendVenueMessage(inviteId: string | number, message: string): Promise<{
-    ok: boolean;
-    result?: any;
-}>;
-/**
- * Get the ticketing event URL
- * @param {string|number} venueId - The venue/event ID
- * @returns {string}
- */
-export function getEventUrl(venueId: string | number): string;
+/**
+ * Accept an event performer invitation
+ * @param {string|number} inviteId - The invitation ID
+ * @param {string} message - Optional message to include
+ * @returns {Promise<{ok: boolean, result?: any}>}
+ */
+export function acceptInvite(inviteId: string | number, message?: string): Promise<{
+    ok: boolean;
+    result?: any;
+}>;
+/**
+ * Decline an event performer invitation
+ * @param {string|number} inviteId - The invitation ID
+ * @param {string} message - Optional message to include
+ * @returns {Promise<{ok: boolean, result?: any}>}
+ */
+export function declineInvite(inviteId: string | number, message?: string): Promise<{
+    ok: boolean;
+    result?: any;
+}>;
+/**
+ * Cancel an event performer invitation
+ * @param {string|number} inviteId - The invitation ID
+ * @param {string} message - Optional message to include
+ * @returns {Promise<{ok: boolean, result?: any}>}
+ */
+export function cancelInvite(inviteId: string | number, message?: string): Promise<{
+    ok: boolean;
+    result?: any;
+}>;
+/**
+ * Send a message to a venue
+ * @param {string|number} inviteId - The invitation/event ID
+ * @param {string} message - The message to send
+ * @returns {Promise<{ok: boolean, result?: any}>}
+ */
+export function sendVenueMessage(inviteId: string | number, message: string): Promise<{
+    ok: boolean;
+    result?: any;
+}>;
+/**
+ * Get the ticketing event URL
+ * @param {string|number} venueId - The venue/event ID
+ * @returns {string}
+ */
+export function getEventUrl(venueId: string | number): string;
 //# sourceMappingURL=ShowService.d.ts.map