@getmicdrop/svelte-components 2.0.6 → 2.0.8

package/dist/components/pages/performers/AvailabilityCalendarModal.svelte

@@ -3,10 +3,10 @@
   import { writable } from "svelte/store";
   import { jwtDecode } from "jwt-decode";
   import QuarterView from "../../Calendar/QuarterView.svelte";
-  import { timeAgo } from "../../utils/utils/utils";
-  import { buildApiUrl, API_ENDPOINTS } from "../../utils/apiConfig.js";
-  import { auth, initializeAuthState } from "../../stores/auth.js";
-  import microphonePlaceholder from "../../assets/images/microphone.png";
+  import { timeAgo } from "../../../utils/utils/utils";
+  import { buildApiUrl, API_ENDPOINTS } from "../../../utils/apiConfig.js";
+  import { auth, initializeAuthState } from "../../../stores/auth.js";
+  import microphonePlaceholder from "../../../assets/images/microphone.png";
 
   export let show = false;
   export let venue = null;

package/dist/components/pages/performers/ModalShowInfo.svelte

@@ -1,5 +1,5 @@
 <script>
-  import { microphonePlaceholder } from "../../utils/utils";
+  import { microphonePlaceholder } from "../../../utils/utils";
 
   export let image;
   export let title;

package/dist/components/pages/performers/ShowItemCard.svelte

@@ -3,14 +3,14 @@
   import Icon from "../../Icons/Icon.svelte";
   import Input from "../../Input/Input.svelte";
   import Modal from "../../Modal/Modal.svelte";
-  import { showToast } from "../../stores/toaster";
-  import { microphonePlaceholder, getUserDetails } from "../../utils/utils";
+  import { showToast } from "../../../stores/toaster";
+  import { microphonePlaceholder, getUserDetails } from "../../../utils/utils";
   import {
     formatHour,
     formattedDate,
     formattedFullDate,
     timeAgo,
-  } from "../../utils/utils/utils";
+  } from "../../../utils/utils/utils";
   import {
     acceptInvite,
     declineInvite,

package/dist/components/pages/performers/VenueInfo.svelte

@@ -1,5 +1,5 @@
 <script>
-  import { parseLocation, microphonePlaceholder } from "../../utils/utils";
+  import { parseLocation, microphonePlaceholder } from "../../../utils/utils";
 
   export let name = "";
   export let image = "";

package/dist/components/pages/performers/VenueItemCard.svelte

@@ -2,10 +2,10 @@
   import Input from "../../Input/Input.svelte";
   import Modal from "../../Modal/Modal.svelte";
   import VenueInfo from "./VenueInfo.svelte";
-  import { showToast } from "../../stores/toaster";
-  import { getPerformerToken } from "../../utils/utils";
-  import { timeAgo } from "../../utils/utils/utils";
-  import { buildApiUrl, API_ENDPOINTS } from "../../utils/apiConfig";
+  import { showToast } from "../../../stores/toaster";
+  import { getPerformerToken } from "../../../utils/utils";
+  import { timeAgo } from "../../../utils/utils/utils";
+  import { buildApiUrl, API_ENDPOINTS } from "../../../utils/apiConfig";
   import { Dropdown, DropdownItem } from "flowbite-svelte";
   import { DotsHorizontalOutline } from "flowbite-svelte-icons";
   import Button from "../../Button/Button.svelte";

package/dist/components/pages/settings/tabs/CustomImageDropzone.svelte

@@ -4,10 +4,10 @@
   export let readonly = false;
   export let shape = "default";
   export let label = "";
-  import CancelIcon from "../../../assets/svg/cancel.svg";
+  import CancelIcon from "../../../../assets/svg/cancel.svg";
 
-  import AddMain from "../../../assets/svg/add-main-01.svg";
-  import CloudUpload from "../../../assets/svg/cloud-upload.svg";
+  import AddMain from "../../../../assets/svg/add-main-01.svg";
+  import CloudUpload from "../../../../assets/svg/cloud-upload.svg";
 
   let images = [];
   let error = "";

package/dist/services/EventService.d.ts

@@ -0,0 +1,5 @@
+export function fetchEventsFromAPI(): Promise<any>;
+export function fetchEventsForMonth(year: any, month: any): Promise<any>;
+export function fetchEventsForWeek(date: any): Promise<any>;
+export function fetchEventsForDay(date: any): Promise<any>;
+//# sourceMappingURL=EventService.d.ts.map

package/dist/services/EventService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventService.d.ts","sourceRoot":"","sources":["../../src/lib/services/EventService.js"],"names":[],"mappings":"AAIA,mDAkBC;AAED,yEAYC;AAED,4DAkBC;AAED,2DAgBC"}

package/dist/services/EventService.js

@@ -0,0 +1,75 @@
+import { addDays, startOfWeek } from "date-fns";
+
+let mockEvents = [];
+
+export async function fetchEventsFromAPI() {
+  try {
+    const response = await fetch("https://get-micdrop.com/api/public/getEventsForVenue");
+    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/EventService.spec.d.ts

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

package/dist/services/EventService.spec.d.ts.map

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

package/dist/services/EventService.spec.js

@@ -0,0 +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);
+  });
+});

package/dist/services/ShowService.d.ts

@@ -0,0 +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

package/dist/services/ShowService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShowService.d.ts","sourceRoot":"","sources":["ShowService.js"],"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/ShowService.js

@@ -0,0 +1,143 @@
+import { API_BASE_URL, API_ENDPOINTS, buildApiUrl } from "../../utils/apiConfig";
+import { getPerformerToken } from "../../utils/utils";
+
+/**
+ * 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 async function acceptInvite(inviteId, message = "") {
+  try {
+    const response = await fetch(
+      buildApiUrl(`${API_ENDPOINTS.ACCEPT_EVENT_PERFORMER_INVITE}/${inviteId}`),
+      {
+        method: "PUT",
+        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
+ * @param {string|number} inviteId - The invitation ID
+ * @param {string} message - Optional message to include
+ * @returns {Promise<{ok: boolean, result?: any}>}
+ */
+export async function declineInvite(inviteId, message = "") {
+  try {
+    const response = await fetch(
+      buildApiUrl(`${API_ENDPOINTS.DECLINE_EVENT_PERFORMER_INVITE}/${inviteId}`),
+      {
+        method: "PUT",
+        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
+ * @param {string|number} inviteId - The invitation ID
+ * @param {string} message - Optional message to include
+ * @returns {Promise<{ok: boolean, result?: any}>}
+ */
+export async function cancelInvite(inviteId, message = "") {
+  try {
+    const response = await fetch(
+      buildApiUrl(`${API_ENDPOINTS.CANCEL_EVENT_PERFORMER_INVITE}/${inviteId}`),
+      {
+        method: "PUT",
+        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
+ * @param {string|number} inviteId - The invitation/event ID
+ * @param {string} message - The message to send
+ * @returns {Promise<{ok: boolean, result?: any}>}
+ */
+export async function sendVenueMessage(inviteId, message) {
+  try {
+    const token = getPerformerToken();
+
+    const response = await fetch(
+      buildApiUrl(`${API_ENDPOINTS.SEND_VENUE_MESSAGE}/${inviteId}`),
+      {
+        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
+ * @param {string|number} venueId - The venue/event ID
+ * @returns {string}
+ */
+export function getEventUrl(venueId) {
+  return `${API_BASE_URL}/ticketing/events/${venueId}`;
+}

package/dist/services/ShowService.spec.d.ts

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

package/dist/services/ShowService.spec.d.ts.map

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

package/dist/services/ShowService.spec.js

@@ -0,0 +1,342 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock the utility modules before imports
+vi.mock('@/utils/apiConfig', () => ({
+  API_BASE_URL: 'https://api.example.com',
+  API_ENDPOINTS: {
+    ACCEPT_EVENT_PERFORMER_INVITE: '/accept-invite',
+    DECLINE_EVENT_PERFORMER_INVITE: '/decline-invite',
+    CANCEL_EVENT_PERFORMER_INVITE: '/cancel-invite',
+    SEND_VENUE_MESSAGE: '/send-message',
+  },
+  buildApiUrl: (path) => `https://api.example.com${path}`,
+}));
+
+vi.mock('@/utils/utils', () => ({
+  getPerformerToken: () => 'test-token',
+}));
+
+import {
+  acceptInvite,
+  declineInvite,
+  cancelInvite,
+  sendVenueMessage,
+  getEventUrl,
+} from './ShowService';
+
+describe('ShowService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    global.fetch = vi.fn();
+  });
+
+  describe('acceptInvite', () => {
+    it('makes PUT request to accept invite endpoint', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      await acceptInvite('123');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://api.example.com/accept-invite/123',
+        expect.objectContaining({
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+        })
+      );
+    });
+
+    it('returns ok: true on successful response', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ id: 123 }),
+      });
+
+      const result = await acceptInvite('123');
+
+      expect(result.ok).toBe(true);
+      expect(result.result).toEqual({ id: 123 });
+    });
+
+    it('returns ok: false on failed response', async () => {
+      global.fetch.mockResolvedValue({
+        ok: false,
+      });
+
+      const result = await acceptInvite('123');
+
+      expect(result.ok).toBe(false);
+    });
+
+    it('returns ok: false on network error', async () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      global.fetch.mockRejectedValue(new Error('Network error'));
+
+      const result = await acceptInvite('123');
+
+      expect(result.ok).toBe(false);
+      consoleSpy.mockRestore();
+    });
+
+    it('includes message in request body', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      await acceptInvite('123', 'Thanks for the invite!');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: JSON.stringify({ message: 'Thanks for the invite!' }),
+        })
+      );
+    });
+
+    it('sends empty message by default', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      await acceptInvite('123');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: JSON.stringify({ message: '' }),
+        })
+      );
+    });
+  });
+
+  describe('declineInvite', () => {
+    it('makes PUT request to decline invite endpoint', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      await declineInvite('456');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://api.example.com/decline-invite/456',
+        expect.objectContaining({
+          method: 'PUT',
+        })
+      );
+    });
+
+    it('returns ok: true on success', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ declined: true }),
+      });
+
+      const result = await declineInvite('456');
+
+      expect(result.ok).toBe(true);
+      expect(result.result).toEqual({ declined: true });
+    });
+
+    it('returns ok: false on failure', async () => {
+      global.fetch.mockResolvedValue({
+        ok: false,
+      });
+
+      const result = await declineInvite('456');
+
+      expect(result.ok).toBe(false);
+    });
+
+    it('returns ok: false on error', async () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      global.fetch.mockRejectedValue(new Error('Error'));
+
+      const result = await declineInvite('456');
+
+      expect(result.ok).toBe(false);
+      consoleSpy.mockRestore();
+    });
+
+    it('includes decline message in body', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      await declineInvite('456', 'Schedule conflict');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: JSON.stringify({ message: 'Schedule conflict' }),
+        })
+      );
+    });
+  });
+
+  describe('cancelInvite', () => {
+    it('makes PUT request to cancel invite endpoint', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      await cancelInvite('789');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://api.example.com/cancel-invite/789',
+        expect.objectContaining({
+          method: 'PUT',
+        })
+      );
+    });
+
+    it('returns ok: true on success', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ cancelled: true }),
+      });
+
+      const result = await cancelInvite('789');
+
+      expect(result.ok).toBe(true);
+    });
+
+    it('returns ok: false on failure', async () => {
+      global.fetch.mockResolvedValue({
+        ok: false,
+      });
+
+      const result = await cancelInvite('789');
+
+      expect(result.ok).toBe(false);
+    });
+
+    it('returns ok: false on error', async () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      global.fetch.mockRejectedValue(new Error('Error'));
+
+      const result = await cancelInvite('789');
+
+      expect(result.ok).toBe(false);
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('sendVenueMessage', () => {
+    it('makes POST request with auth token', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        text: () => Promise.resolve(''),
+      });
+
+      await sendVenueMessage('123', 'Hello!');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://api.example.com/send-message/123',
+        expect.objectContaining({
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer test-token',
+          },
+          credentials: 'include',
+        })
+      );
+    });
+
+    it('sends message in request body', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        text: () => Promise.resolve(''),
+      });
+
+      await sendVenueMessage('123', 'Hello venue!');
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: JSON.stringify({ message: 'Hello venue!' }),
+        })
+      );
+    });
+
+    it('returns ok: true with default message on empty response', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        text: () => Promise.resolve(''),
+      });
+
+      const result = await sendVenueMessage('123', 'Hello');
+
+      expect(result.ok).toBe(true);
+      expect(result.result).toEqual({ message: 'Email sent successfully' });
+    });
+
+    it('parses JSON response when present', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        text: () => Promise.resolve(JSON.stringify({ sent: true, id: 456 })),
+      });
+
+      const result = await sendVenueMessage('123', 'Hello');
+
+      expect(result.ok).toBe(true);
+      expect(result.result).toEqual({ sent: true, id: 456 });
+    });
+
+    it('handles invalid JSON in response gracefully', async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        text: () => Promise.resolve('not json'),
+      });
+
+      const result = await sendVenueMessage('123', 'Hello');
+
+      expect(result.ok).toBe(true);
+      expect(result.result).toEqual({ message: 'Email sent successfully' });
+    });
+
+    it('returns ok: false on failure', async () => {
+      global.fetch.mockResolvedValue({
+        ok: false,
+      });
+
+      const result = await sendVenueMessage('123', 'Hello');
+
+      expect(result.ok).toBe(false);
+    });
+
+    it('returns ok: false on error', async () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      global.fetch.mockRejectedValue(new Error('Network error'));
+
+      const result = await sendVenueMessage('123', 'Hello');
+
+      expect(result.ok).toBe(false);
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('getEventUrl', () => {
+    it('returns ticketing URL for venue', () => {
+      const url = getEventUrl('123');
+      expect(url).toBe('https://api.example.com/ticketing/events/123');
+    });
+
+    it('handles numeric venue ID', () => {
+      const url = getEventUrl(456);
+      expect(url).toBe('https://api.example.com/ticketing/events/456');
+    });
+
+    it('handles string venue ID', () => {
+      const url = getEventUrl('venue-abc');
+      expect(url).toBe('https://api.example.com/ticketing/events/venue-abc');
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmicdrop/svelte-components",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "Shared component library for Micdrop applications",
   "type": "module",
   "main": "./dist/index.js",