@getmicdrop/svelte-components 5.17.4 → 5.19.0

package/dist/services/event.service.d.ts

@@ -0,0 +1,11 @@
+interface CalendarEvent {
+    id: number;
+    date: string;
+    title: string;
+}
+export declare function fetchEventsFromAPI(venueId?: string | number): Promise<CalendarEvent[]>;
+export declare function fetchEventsForMonth(year: number, month: number): Promise<CalendarEvent[]>;
+export declare function fetchEventsForWeek(date: Date): Promise<CalendarEvent[]>;
+export declare function fetchEventsForDay(date: Date): Promise<CalendarEvent[]>;
+export {};
+//# sourceMappingURL=event.service.d.ts.map

package/dist/services/event.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.service.d.ts","sourceRoot":"","sources":["../../src/lib/services/event.service.ts"],"names":[],"mappings":"AAGA,UAAU,aAAa;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAID,wBAAsB,kBAAkB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAqB5F;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAY/F;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAkB7E;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAgB5E"}

package/dist/services/event.service.js

@@ -0,0 +1,64 @@
+import { addDays, startOfWeek } from "date-fns";
+import { buildApiUrl } from "../utils/apiConfig";
+let mockEvents = [];
+export async function fetchEventsFromAPI(venueId) {
+    try {
+        const url = venueId
+            ? buildApiUrl(`/api/v2/public/events/venue/${venueId}`)
+            : buildApiUrl("/api/v2/public/events/venue");
+        const response = await fetch(url);
+        if (response.ok) {
+            const events = await response.json();
+            return events.map((event) => ({
+                id: event.ID,
+                date: event.startDateTime,
+                title: event.title,
+            }));
+        }
+        else {
+            console.error("Failed to load events:", response.status);
+            return [];
+        }
+    }
+    catch (error) {
+        console.error("Error fetching events:", error);
+        return [];
+    }
+}
+export async function fetchEventsForMonth(year, month) {
+    mockEvents = await fetchEventsFromAPI();
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve(mockEvents.filter((event) => event.date.startsWith(`${year}-${String(month).padStart(2, "0")}`)));
+        }, 500);
+    });
+}
+export async function fetchEventsForWeek(date) {
+    mockEvents = await fetchEventsFromAPI();
+    const startOfWeekDate = startOfWeek(date, { weekStartsOn: 1 });
+    const endOfWeekDate = addDays(startOfWeekDate, 6);
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            const filteredEvents = mockEvents.filter((event) => {
+                const eventDate = new Date(event.date).getTime();
+                return (eventDate >= startOfWeekDate.getTime() &&
+                    eventDate <= endOfWeekDate.getTime());
+            });
+            resolve(filteredEvents);
+        }, 500);
+    });
+}
+export async function fetchEventsForDay(date) {
+    mockEvents = await fetchEventsFromAPI();
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            const filteredEvents = mockEvents.filter((event) => {
+                const eventDate = new Date(event.date);
+                return (eventDate.getUTCDate() === date.getUTCDate() &&
+                    eventDate.getUTCMonth() === date.getUTCMonth() &&
+                    eventDate.getUTCFullYear() === date.getUTCFullYear());
+            });
+            resolve(filteredEvents);
+        }, 500);
+    });
+}

package/dist/services/event.service.spec.d.ts

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

package/dist/services/event.service.spec.d.ts.map

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

package/dist/services/event.service.spec.js

@@ -0,0 +1,168 @@
+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 './event.service';
+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/v2/public/events/venue');
+            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 → show.service.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;
-//# sourceMappingURL=ShowService.d.ts.map
+/**
+ * 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=show.service.d.ts.map

package/dist/services/show.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"show.service.d.ts","sourceRoot":"","sources":["show.service.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,uCAJW,MAAM,GAAC,MAAM,YACb,MAAM,GACJ,OAAO,CAAC;IAAC,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,GAAG,CAAA;CAAC,CAAC,CAwBhD;AAED;;;;;GAKG;AACH,wCAJW,MAAM,GAAC,MAAM,YACb,MAAM,GACJ,OAAO,CAAC;IAAC,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,GAAG,CAAA;CAAC,CAAC,CAwBhD;AAED;;;;;GAKG;AACH,uCAJW,MAAM,GAAC,MAAM,YACb,MAAM,GACJ,OAAO,CAAC;IAAC,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,GAAG,CAAA;CAAC,CAAC,CAwBhD;AAED;;;;;GAKG;AACH,2CAJW,MAAM,GAAC,MAAM,WACb,MAAM,GACJ,OAAO,CAAC;IAAC,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,GAAG,CAAA;CAAC,CAAC,CAoChD;AAED;;;;GAIG;AACH,qCAHW,MAAM,GAAC,MAAM,GACX,MAAM,CAIlB"}

package/dist/services/show.service.js

@@ -0,0 +1,115 @@
+import { API_BASE_URL, USE_V2_API, buildApiUrl, buildPerformerInviteUrl, getPerformerInviteMethod } from "../utils/apiConfig";
+import { getPerformerToken } from "../utils/utils";
+/**
+ * Accept an event performer invitation
+ */
+export async function acceptInvite(inviteId, message = "") {
+    try {
+        const response = await fetch(buildPerformerInviteUrl(inviteId, "accept"), {
+            method: getPerformerInviteMethod("accept"),
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ message }),
+        });
+        if (response.ok) {
+            const result = await response.json();
+            return { ok: true, result };
+        }
+        return { ok: false };
+    }
+    catch (error) {
+        console.error("Error accepting invite:", error);
+        return { ok: false };
+    }
+}
+/**
+ * Decline an event performer invitation
+ */
+export async function declineInvite(inviteId, message = "") {
+    try {
+        const response = await fetch(buildPerformerInviteUrl(inviteId, "decline"), {
+            method: getPerformerInviteMethod("decline"),
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ message }),
+        });
+        if (response.ok) {
+            const result = await response.json();
+            return { ok: true, result };
+        }
+        return { ok: false };
+    }
+    catch (error) {
+        console.error("Error declining invite:", error);
+        return { ok: false };
+    }
+}
+/**
+ * Cancel an event performer invitation
+ */
+export async function cancelInvite(inviteId, message = "") {
+    try {
+        const response = await fetch(buildPerformerInviteUrl(inviteId, "cancel"), {
+            method: getPerformerInviteMethod("cancel"),
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ message }),
+        });
+        if (response.ok) {
+            const result = await response.json();
+            return { ok: true, result };
+        }
+        return { ok: false };
+    }
+    catch (error) {
+        console.error("Error cancelling invite:", error);
+        return { ok: false };
+    }
+}
+/**
+ * Send a message to a venue
+ */
+export async function sendVenueMessage(inviteId, message) {
+    try {
+        const token = getPerformerToken();
+        const url = USE_V2_API
+            ? buildApiUrl(`/api/v2/performer/invites/${inviteId}/message`)
+            : buildApiUrl(`/api/performer/sendVenueMessage/${inviteId}`);
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            credentials: "include",
+            body: JSON.stringify({ message }),
+        });
+        if (response.ok) {
+            const text = await response.text();
+            let result = { message: "Email sent successfully" };
+            if (text) {
+                try {
+                    result = JSON.parse(text);
+                }
+                catch (_e) {
+                    // Empty response is fine
+                }
+            }
+            return { ok: true, result };
+        }
+        return { ok: false };
+    }
+    catch (error) {
+        console.error("Error sending venue message:", error);
+        return { ok: false };
+    }
+}
+/**
+ * Get the ticketing event URL
+ */
+export function getEventUrl(venueId) {
+    return `${API_BASE_URL}/ticketing/events/${venueId}`;
+}

package/dist/services/show.service.spec.d.ts

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

package/dist/services/show.service.spec.d.ts.map

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