@getmicdrop/svelte-components 5.17.1 → 5.17.3

package/dist/stores/auth.svelte.spec.d.ts

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

package/dist/stores/auth.svelte.spec.d.ts.map

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

package/dist/stores/auth.svelte.spec.js

@@ -0,0 +1,112 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { auth, setAuthState, clearAuthState, initializeAuthState } from './auth.svelte';
+describe('auth store', () => {
+    beforeEach(() => {
+        clearAuthState();
+    });
+    describe('default state', () => {
+        it('starts not authenticated', () => {
+            expect(auth.isAuthenticated).toBe(false);
+        });
+        it('starts with null token', () => {
+            expect(auth.token).toBeNull();
+        });
+        it('starts with null userDetails', () => {
+            expect(auth.userDetails).toBeNull();
+        });
+        it('value returns the full state', () => {
+            expect(auth.value).toEqual({
+                isAuthenticated: false,
+                token: null,
+                userDetails: null,
+            });
+        });
+    });
+    describe('setAuthState', () => {
+        it('updates authentication state', () => {
+            const state = {
+                isAuthenticated: true,
+                token: 'test-token',
+                userDetails: { email: 'test@example.com' },
+            };
+            setAuthState(state);
+            expect(auth.isAuthenticated).toBe(true);
+            expect(auth.token).toBe('test-token');
+            expect(auth.userDetails).toEqual({ email: 'test@example.com' });
+        });
+        it('updates value getter', () => {
+            const state = {
+                isAuthenticated: true,
+                token: 'abc',
+                userDetails: null,
+            };
+            setAuthState(state);
+            expect(auth.value).toEqual(state);
+        });
+    });
+    describe('clearAuthState', () => {
+        it('resets to default state', () => {
+            setAuthState({
+                isAuthenticated: true,
+                token: 'token',
+                userDetails: { email: 'test@test.com' },
+            });
+            clearAuthState();
+            expect(auth.isAuthenticated).toBe(false);
+            expect(auth.token).toBeNull();
+            expect(auth.userDetails).toBeNull();
+        });
+    });
+    describe('initializeAuthState', () => {
+        const originalDocument = globalThis.document;
+        it('returns early when document is undefined (SSR)', () => {
+            const docDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'document');
+            // @ts-expect-error simulating server
+            Object.defineProperty(globalThis, 'document', { value: undefined, writable: true, configurable: true });
+            initializeAuthState();
+            expect(auth.isAuthenticated).toBe(false);
+            // Restore
+            if (docDescriptor) {
+                Object.defineProperty(globalThis, 'document', docDescriptor);
+            }
+        });
+        it('sets auth state from performer_token cookie', () => {
+            Object.defineProperty(document, 'cookie', {
+                get: () => 'performer_token=my-jwt-token',
+                configurable: true,
+            });
+            initializeAuthState();
+            expect(auth.isAuthenticated).toBe(true);
+            expect(auth.token).toBe('my-jwt-token');
+            expect(auth.userDetails).toBeNull();
+        });
+        it('parses userDetails cookie as JSON', () => {
+            const userDetails = { email: 'user@test.com', firstName: 'John' };
+            Object.defineProperty(document, 'cookie', {
+                get: () => `performer_token=token123; userDetails=${encodeURIComponent(JSON.stringify(userDetails))}`,
+                configurable: true,
+            });
+            initializeAuthState();
+            expect(auth.isAuthenticated).toBe(true);
+            expect(auth.token).toBe('token123');
+            expect(auth.userDetails).toEqual(userDetails);
+        });
+        it('does not set auth when no performer_token cookie', () => {
+            Object.defineProperty(document, 'cookie', {
+                get: () => 'other_cookie=value',
+                configurable: true,
+            });
+            initializeAuthState();
+            expect(auth.isAuthenticated).toBe(false);
+            expect(auth.token).toBeNull();
+        });
+        it('handles empty cookie string', () => {
+            Object.defineProperty(document, 'cookie', {
+                get: () => '',
+                configurable: true,
+            });
+            initializeAuthState();
+            expect(auth.isAuthenticated).toBe(false);
+        });
+    });
+});

package/dist/stores/formDataStore.svelte.spec.d.ts

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

package/dist/stores/formDataStore.svelte.spec.d.ts.map

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

package/dist/stores/formDataStore.svelte.spec.js

@@ -0,0 +1,150 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { profileFormData, initialFormData, hasChanges } from './formDataStore.svelte';
+describe('formDataStore', () => {
+    beforeEach(() => {
+        profileFormData.reset();
+        initialFormData.reset();
+    });
+    describe('profileFormData', () => {
+        it('starts with default empty values', () => {
+            const data = profileFormData.value;
+            expect(data.basicInfo.firstName).toBe('');
+            expect(data.basicInfo.lastName).toBe('');
+            expect(data.basicInfo.email).toBe('');
+            expect(data.basicInfo.phone).toBe('');
+            expect(data.basicInfo.stageName).toBe('');
+            expect(data.basicInfo.location).toBe('');
+            expect(data.socialMedia.videoLink).toBe('');
+            expect(data.extraDetails).toEqual({});
+        });
+        it('can set value', () => {
+            profileFormData.value = {
+                basicInfo: {
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    email: 'john@test.com',
+                    phone: '1234567890',
+                    stageName: 'JD',
+                    location: 'NYC',
+                },
+                socialMedia: { videoLink: 'https://youtube.com' },
+                extraDetails: { bio: 'Hello' },
+            };
+            expect(profileFormData.value.basicInfo.firstName).toBe('John');
+            expect(profileFormData.value.socialMedia.videoLink).toBe('https://youtube.com');
+            expect(profileFormData.value.extraDetails).toEqual({ bio: 'Hello' });
+        });
+        it('can get and set basicInfo', () => {
+            const info = {
+                firstName: 'Jane',
+                lastName: 'Smith',
+                email: 'jane@test.com',
+                phone: '555-1234',
+                stageName: 'JS',
+                location: 'LA',
+            };
+            profileFormData.basicInfo = info;
+            expect(profileFormData.basicInfo).toEqual(info);
+        });
+        it('can get and set socialMedia', () => {
+            profileFormData.socialMedia = { videoLink: 'https://vimeo.com' };
+            expect(profileFormData.socialMedia.videoLink).toBe('https://vimeo.com');
+        });
+        it('can get and set extraDetails', () => {
+            profileFormData.extraDetails = { genre: 'rock', bio: 'musician' };
+            expect(profileFormData.extraDetails).toEqual({ genre: 'rock', bio: 'musician' });
+        });
+        it('update applies a function to the data', () => {
+            profileFormData.update((data) => ({
+                ...data,
+                basicInfo: { ...data.basicInfo, firstName: 'Updated' },
+            }));
+            expect(profileFormData.basicInfo.firstName).toBe('Updated');
+        });
+        it('reset restores to default values', () => {
+            profileFormData.basicInfo = {
+                firstName: 'Modified',
+                lastName: 'User',
+                email: 'mod@test.com',
+                phone: '000',
+                stageName: 'MU',
+                location: 'SF',
+            };
+            profileFormData.reset();
+            expect(profileFormData.basicInfo.firstName).toBe('');
+            expect(profileFormData.basicInfo.lastName).toBe('');
+        });
+    });
+    describe('initialFormData', () => {
+        it('starts as null', () => {
+            expect(initialFormData.value).toBeNull();
+        });
+        it('can set value', () => {
+            const data = {
+                basicInfo: {
+                    firstName: 'A',
+                    lastName: 'B',
+                    email: 'a@b.com',
+                    phone: '1',
+                    stageName: 'AB',
+                    location: 'X',
+                },
+                socialMedia: { videoLink: '' },
+                extraDetails: {},
+            };
+            initialFormData.value = data;
+            expect(initialFormData.value).toEqual(data);
+        });
+        it('can set value matching current profile data', () => {
+            profileFormData.basicInfo = {
+                firstName: 'Current',
+                lastName: 'State',
+                email: 'c@s.com',
+                phone: '1',
+                stageName: 'CS',
+                location: 'Y',
+            };
+            // Use JSON clone to avoid structuredClone proxy issues in test
+            initialFormData.value = JSON.parse(JSON.stringify(profileFormData.value));
+            expect(initialFormData.value).not.toBeNull();
+            expect(initialFormData.value.basicInfo.firstName).toBe('Current');
+            // Should be a clone, not a reference
+            profileFormData.basicInfo = { ...profileFormData.basicInfo, firstName: 'Changed' };
+            expect(initialFormData.value.basicInfo.firstName).toBe('Current');
+        });
+        it('reset sets value to null', () => {
+            initialFormData.value = {
+                basicInfo: { firstName: '', lastName: '', email: '', phone: '', stageName: '', location: '' },
+                socialMedia: { videoLink: '' },
+                extraDetails: {},
+            };
+            initialFormData.reset();
+            expect(initialFormData.value).toBeNull();
+        });
+    });
+    describe('hasChanges', () => {
+        it('returns false when initialFormData is null', () => {
+            expect(hasChanges.value).toBe(false);
+        });
+        it('returns false when data matches initial', () => {
+            // Use value assignment instead of setFromCurrent to avoid structuredClone proxy issues
+            initialFormData.value = JSON.parse(JSON.stringify(profileFormData.value));
+            expect(hasChanges.value).toBe(false);
+        });
+        it('returns true when data differs from initial', () => {
+            initialFormData.value = JSON.parse(JSON.stringify(profileFormData.value));
+            profileFormData.basicInfo = {
+                ...profileFormData.basicInfo,
+                firstName: 'Changed',
+            };
+            expect(hasChanges.value).toBe(true);
+        });
+        it('returns false again after resetting data to match initial', () => {
+            initialFormData.value = JSON.parse(JSON.stringify(profileFormData.value));
+            profileFormData.basicInfo = { ...profileFormData.basicInfo, firstName: 'Changed' };
+            expect(hasChanges.value).toBe(true);
+            profileFormData.basicInfo = { ...profileFormData.basicInfo, firstName: '' };
+            expect(hasChanges.value).toBe(false);
+        });
+    });
+});

package/dist/stores/formSave.svelte.spec.d.ts

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

package/dist/stores/formSave.svelte.spec.d.ts.map

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

package/dist/stores/formSave.svelte.spec.js

@@ -0,0 +1,196 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+// Mock svelte-sonner before importing
+vi.mock('svelte-sonner', () => ({
+    toast: {
+        success: vi.fn(),
+        error: vi.fn(),
+        message: vi.fn(),
+    },
+}));
+import { createFormSave, createDirtyTracker } from './formSave.svelte';
+describe('createFormSave', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Reset global fetch mock
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('returns an object with expected properties', () => {
+        const formSave = createFormSave();
+        expect(formSave).toHaveProperty('isLoading');
+        expect(formSave).toHaveProperty('isSuccess');
+        expect(formSave).toHaveProperty('error');
+        expect(formSave).toHaveProperty('save');
+        expect(formSave).toHaveProperty('resetSuccess');
+        expect(formSave).toHaveProperty('reset');
+    });
+    it('starts with default state', () => {
+        const formSave = createFormSave();
+        expect(formSave.isLoading).toBe(false);
+        expect(formSave.isSuccess).toBe(false);
+        expect(formSave.error).toBeNull();
+    });
+    it('returns false and logs error when no endpoint provided', async () => {
+        const spy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        const formSave = createFormSave();
+        const result = await formSave.save({ name: 'test' });
+        expect(result).toBe(false);
+        expect(spy).toHaveBeenCalledWith('No endpoint specified for form save');
+        spy.mockRestore();
+    });
+    it('saves successfully to configured endpoint', async () => {
+        const onSuccess = vi.fn();
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({}),
+        });
+        const formSave = createFormSave({
+            endpoint: '/api/save',
+            successMessage: 'Saved!',
+            onSuccess,
+        });
+        const result = await formSave.save({ name: 'test' });
+        expect(result).toBe(true);
+        expect(formSave.isSuccess).toBe(true);
+        expect(formSave.isLoading).toBe(false);
+        expect(formSave.error).toBeNull();
+        expect(onSuccess).toHaveBeenCalled();
+        expect(fetch).toHaveBeenCalledWith('/api/save', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: 'test' }),
+        });
+    });
+    it('uses custom endpoint over configured one', async () => {
+        vi.mocked(fetch).mockResolvedValue({ ok: true, json: () => Promise.resolve({}) });
+        const formSave = createFormSave({ endpoint: '/api/default' });
+        await formSave.save({ data: 1 }, '/api/custom');
+        expect(fetch).toHaveBeenCalledWith('/api/custom', expect.any(Object));
+    });
+    it('handles server error response', async () => {
+        const onError = vi.fn();
+        vi.mocked(fetch).mockResolvedValue({
+            ok: false,
+            json: () => Promise.resolve({ message: 'Validation failed' }),
+        });
+        const formSave = createFormSave({
+            endpoint: '/api/save',
+            errorMessage: 'Default error',
+            onError,
+        });
+        const result = await formSave.save({ name: '' });
+        expect(result).toBe(false);
+        expect(formSave.isSuccess).toBe(false);
+        expect(formSave.error).toBe('Validation failed');
+        expect(onError).toHaveBeenCalledWith('Validation failed');
+    });
+    it('uses default error message when server returns no message', async () => {
+        vi.mocked(fetch).mockResolvedValue({
+            ok: false,
+            json: () => Promise.resolve({}),
+        });
+        const formSave = createFormSave({
+            endpoint: '/api/save',
+            errorMessage: 'Save failed',
+        });
+        const result = await formSave.save({ name: '' });
+        expect(result).toBe(false);
+        expect(formSave.error).toBe('Save failed');
+    });
+    it('handles non-JSON error response', async () => {
+        vi.mocked(fetch).mockResolvedValue({
+            ok: false,
+            json: () => Promise.reject(new Error('not json')),
+        });
+        const formSave = createFormSave({
+            endpoint: '/api/save',
+            errorMessage: 'Default error',
+        });
+        const result = await formSave.save({ data: 1 });
+        expect(result).toBe(false);
+        expect(formSave.error).toBe('Default error');
+    });
+    it('handles network errors', async () => {
+        const onError = vi.fn();
+        vi.mocked(fetch).mockRejectedValue(new Error('Network error'));
+        const formSave = createFormSave({
+            endpoint: '/api/save',
+            onError,
+        });
+        const result = await formSave.save({ data: 1 });
+        expect(result).toBe(false);
+        expect(formSave.error).toBe('Network error');
+        expect(formSave.isLoading).toBe(false);
+        expect(onError).toHaveBeenCalledWith('Network error');
+    });
+    it('handles non-Error exceptions', async () => {
+        vi.mocked(fetch).mockRejectedValue('string error');
+        const formSave = createFormSave({ endpoint: '/api/save' });
+        const result = await formSave.save({ data: 1 });
+        expect(result).toBe(false);
+        expect(formSave.error).toBe('Something went wrong');
+    });
+    it('does not show toast when successMessage is empty', async () => {
+        const { toast } = await import('svelte-sonner');
+        vi.mocked(fetch).mockResolvedValue({ ok: true, json: () => Promise.resolve({}) });
+        const formSave = createFormSave({
+            endpoint: '/api/save',
+            successMessage: '',
+        });
+        await formSave.save({ data: 1 });
+        expect(toast.success).not.toHaveBeenCalled();
+    });
+    it('resetSuccess clears success state', async () => {
+        vi.mocked(fetch).mockResolvedValue({ ok: true, json: () => Promise.resolve({}) });
+        const formSave = createFormSave({ endpoint: '/api/save' });
+        await formSave.save({ data: 1 });
+        expect(formSave.isSuccess).toBe(true);
+        formSave.resetSuccess();
+        expect(formSave.isSuccess).toBe(false);
+    });
+    it('reset clears all states', async () => {
+        vi.mocked(fetch).mockRejectedValue(new Error('err'));
+        const formSave = createFormSave({ endpoint: '/api/save' });
+        await formSave.save({ data: 1 });
+        expect(formSave.error).toBe('err');
+        formSave.reset();
+        expect(formSave.isLoading).toBe(false);
+        expect(formSave.isSuccess).toBe(false);
+        expect(formSave.error).toBeNull();
+    });
+});
+describe('createDirtyTracker', () => {
+    it('starts as not dirty', () => {
+        const tracker = createDirtyTracker({ name: 'John' });
+        expect(tracker.isDirty).toBe(false);
+    });
+    it('detects changes', () => {
+        const tracker = createDirtyTracker({ name: 'John' });
+        const result = tracker.check({ name: 'Jane' });
+        expect(result).toBe(true);
+        expect(tracker.isDirty).toBe(true);
+    });
+    it('detects no changes', () => {
+        const tracker = createDirtyTracker({ name: 'John' });
+        const result = tracker.check({ name: 'John' });
+        expect(result).toBe(false);
+        expect(tracker.isDirty).toBe(false);
+    });
+    it('reset updates initial data and clears dirty state', () => {
+        const tracker = createDirtyTracker({ name: 'John' });
+        tracker.check({ name: 'Jane' });
+        expect(tracker.isDirty).toBe(true);
+        tracker.reset({ name: 'Jane' });
+        expect(tracker.isDirty).toBe(false);
+        // Now checking against new initial data
+        const result = tracker.check({ name: 'Jane' });
+        expect(result).toBe(false);
+    });
+    it('handles nested objects', () => {
+        const tracker = createDirtyTracker({ user: { name: 'John', age: 30 } });
+        expect(tracker.check({ user: { name: 'John', age: 30 } })).toBe(false);
+        expect(tracker.check({ user: { name: 'John', age: 31 } })).toBe(true);
+    });
+});

package/dist/stores/navigation.spec.d.ts

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

package/dist/stores/navigation.spec.d.ts.map

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

package/dist/stores/navigation.spec.js

@@ -0,0 +1,53 @@
+import { describe, it, expect } from 'vitest';
+import { get } from 'svelte/store';
+import { isSubPage, hideHeaderBackButton, selectedVenueData, isAnimatedNavigation, } from './navigation.svelte';
+describe('navigation stores', () => {
+    describe('isSubPage', () => {
+        it('defaults to false', () => {
+            expect(get(isSubPage)).toBe(false);
+        });
+        it('can be set to true', () => {
+            isSubPage.set(true);
+            expect(get(isSubPage)).toBe(true);
+            isSubPage.set(false); // reset
+        });
+    });
+    describe('hideHeaderBackButton', () => {
+        it('defaults to false', () => {
+            expect(get(hideHeaderBackButton)).toBe(false);
+        });
+        it('can be set to true', () => {
+            hideHeaderBackButton.set(true);
+            expect(get(hideHeaderBackButton)).toBe(true);
+            hideHeaderBackButton.set(false); // reset
+        });
+    });
+    describe('selectedVenueData', () => {
+        it('defaults to null', () => {
+            expect(get(selectedVenueData)).toBeNull();
+        });
+        it('can be set to an object', () => {
+            const data = { id: 1, name: 'Test Venue' };
+            selectedVenueData.set(data);
+            expect(get(selectedVenueData)).toEqual(data);
+            selectedVenueData.set(null); // reset
+        });
+        it('can be updated', () => {
+            selectedVenueData.set({ id: 1 });
+            selectedVenueData.update(current => ({ ...current, name: 'Updated' }));
+            expect(get(selectedVenueData)).toEqual({ id: 1, name: 'Updated' });
+            selectedVenueData.set(null); // reset
+        });
+    });
+    describe('isAnimatedNavigation', () => {
+        it('defaults to false', () => {
+            expect(get(isAnimatedNavigation)).toBe(false);
+        });
+        it('can be toggled', () => {
+            isAnimatedNavigation.set(true);
+            expect(get(isAnimatedNavigation)).toBe(true);
+            isAnimatedNavigation.set(false);
+            expect(get(isAnimatedNavigation)).toBe(false);
+        });
+    });
+});

package/dist/stores/toaster.js

@@ -1,13 +1,13 @@
-import { toast } from "svelte-sonner";
-
-export { toast };
-
-export const showToast = (message, type = "success") => {
-  if (type === "success") {
-    toast.success(message);
-  } else if (type === "error") {
-    toast.error(message);
-  } else {
-    toast.message(message);
-  }
-};
+import { toast } from "svelte-sonner";
+
+export { toast };
+
+export const showToast = (message, type = "success") => {
+  if (type === "success") {
+    toast.success(message);
+  } else if (type === "error") {
+    toast.error(message);
+  } else {
+    toast.message(message);
+  }
+};

package/dist/stories/ButtonAuditReview.stories.svelte

@@ -1,14 +1,14 @@
-<script module>
-  import { defineMeta } from "@storybook/addon-svelte-csf";
-  import ButtonAuditReview from "./ButtonAuditReview.svelte";
-
-  const { Story } = defineMeta({
-    title: "Design System/Button Audit Review",
-    component: ButtonAuditReview,
-    parameters: {
-      layout: 'fullscreen',
-    }
-  });
-</script>
-
-<Story name="All Issues" />
+<script module>
+  import { defineMeta } from "@storybook/addon-svelte-csf";
+  import ButtonAuditReview from "./ButtonAuditReview.svelte";
+
+  const { Story } = defineMeta({
+    title: "Design System/Button Audit Review",
+    component: ButtonAuditReview,
+    parameters: {
+      layout: 'fullscreen',
+    }
+  });
+</script>
+
+<Story name="All Issues" />