@getmicdrop/svelte-components 5.3.13 → 5.3.14

package/dist/stores/auth.spec.js

@@ -1,447 +1,139 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { get } from 'svelte/store';
-import {
-  auth,
-  isPerformer,
-  setAuthState,
-  clearAuthState,
-  initializeAuthState,
-  updateTokens,
-  setPermissions,
-  setContext,
-  hasPermission,
-  getPermissions,
-  isTokenExpiringSoon
-} from './auth';
-
-// Mock jwt-decode
-vi.mock('jwt-decode', () => ({
-  jwtDecode: vi.fn((token) => {
-    // Parse mock tokens in format: "token-exp-{timestamp}"
-    if (token.startsWith('token-exp-')) {
-      const exp = parseInt(token.replace('token-exp-', ''), 10);
-      return { exp: exp / 1000 }; // Convert ms to seconds (JWT uses seconds)
-    }
-    // Default: return token that expires in 1 hour
-    return { exp: (Date.now() + 3600000) / 1000 };
-  })
-}));
-
-describe('auth store', () => {
-  beforeEach(() => {
-    // Reset auth state before each test
-    clearAuthState();
-    // Clear cookies
-    Object.defineProperty(document, 'cookie', {
-      writable: true,
-      value: '',
-    });
-  });
-
-  describe('initial state', () => {
-    it('starts with isAuthenticated as false', () => {
-      expect(get(auth).isAuthenticated).toBe(false);
-    });
-
-    it('starts with token as null', () => {
-      expect(get(auth).token).toBe(null);
-    });
-
-    it('starts with userDetails as null', () => {
-      expect(get(auth).userDetails).toBe(null);
-    });
-  });
-
-  describe('setAuthState', () => {
-    it('sets authentication state', () => {
-      setAuthState({
-        isAuthenticated: true,
-        token: 'test-token',
-        userDetails: { email: 'test@test.com' },
-      });
-
-      const state = get(auth);
-      expect(state.isAuthenticated).toBe(true);
-      expect(state.token).toBe('test-token');
-      expect(state.userDetails).toEqual({ email: 'test@test.com' });
-    });
-
-    it('can update partial state', () => {
-      setAuthState({ isAuthenticated: true, token: 'token1', userDetails: null });
-      setAuthState({ isAuthenticated: true, token: 'token2', userDetails: { name: 'User' } });
-
-      const state = get(auth);
-      expect(state.token).toBe('token2');
-      expect(state.userDetails).toEqual({ name: 'User' });
-    });
-  });
-
-  describe('clearAuthState', () => {
-    it('clears authentication state', () => {
-      setAuthState({
-        isAuthenticated: true,
-        token: 'test-token',
-        userDetails: { email: 'test@test.com' },
-      });
-
-      clearAuthState();
-
-      const state = get(auth);
-      expect(state.isAuthenticated).toBe(false);
-      expect(state.token).toBe(null);
-      expect(state.userDetails).toBe(null);
-    });
-  });
-
-  describe('initializeAuthState', () => {
-    it('does nothing when no performer_token cookie exists', () => {
-      Object.defineProperty(document, 'cookie', {
-        writable: true,
-        value: '',
-      });
-
-      initializeAuthState();
-
-      const state = get(auth);
-      expect(state.isAuthenticated).toBe(false);
-    });
-
-    it('sets auth state from performer_token cookie', () => {
-      Object.defineProperty(document, 'cookie', {
-        writable: true,
-        value: 'performer_token=my-token',
-      });
-
-      initializeAuthState();
-
-      const state = get(auth);
-      expect(state.isAuthenticated).toBe(true);
-      expect(state.token).toBe('my-token');
-    });
-
-    it('parses userDetails cookie when present', () => {
-      const userDetails = JSON.stringify({ email: 'test@test.com', firstName: 'Test' });
-      Object.defineProperty(document, 'cookie', {
-        writable: true,
-        value: `performer_token=my-token; userDetails=${encodeURIComponent(userDetails)}`,
-      });
-
-      initializeAuthState();
-
-      const state = get(auth);
-      expect(state.userDetails).toEqual({ email: 'test@test.com', firstName: 'Test' });
-    });
-
-    it('handles missing userDetails cookie', () => {
-      Object.defineProperty(document, 'cookie', {
-        writable: true,
-        value: 'performer_token=my-token',
-      });
-
-      initializeAuthState();
-
-      const state = get(auth);
-      expect(state.isAuthenticated).toBe(true);
-      expect(state.userDetails).toBe(null);
-    });
-  });
-
-  describe('store subscription', () => {
-    it('can subscribe to auth changes', () => {
-      const values = [];
-      const unsubscribe = auth.subscribe((value) => {
-        values.push(value.isAuthenticated);
-      });
-
-      setAuthState({ isAuthenticated: true, token: 'token', userDetails: null });
-      clearAuthState();
-
-      unsubscribe();
-
-      expect(values).toEqual([false, true, false]);
-    });
-  });
-
-  describe('updateTokens', () => {
-    it('updates access token and computes new expiry', () => {
-      setAuthState({
-        isAuthenticated: true,
-        token: 'old-token',
-        refreshToken: 'old-refresh',
-        userDetails: null,
-      });
-
-      updateTokens('new-access-token', 'new-refresh-token');
-
-      const state = get(auth);
-      expect(state.token).toBe('new-access-token');
-      expect(state.refreshToken).toBe('new-refresh-token');
-      expect(state.tokenExpiry).toBeDefined();
-    });
-
-    it('preserves existing refresh token if not provided', () => {
-      setAuthState({
-        isAuthenticated: true,
-        token: 'old-token',
-        refreshToken: 'existing-refresh',
-        userDetails: null,
-      });
-
-      updateTokens('new-access-token');
-
-      const state = get(auth);
-      expect(state.token).toBe('new-access-token');
-      expect(state.refreshToken).toBe('existing-refresh');
-    });
-
-    it('preserves other state properties when updating tokens', () => {
-      setAuthState({
-        isAuthenticated: true,
-        token: 'old-token',
-        refreshToken: 'refresh',
-        userDetails: { email: 'test@test.com' },
-        permissions: { events: { read: true } },
-        context: { contextType: 'performer' },
-      });
-
-      updateTokens('new-token');
-
-      const state = get(auth);
-      expect(state.userDetails).toEqual({ email: 'test@test.com' });
-      expect(state.permissions).toEqual({ events: { read: true } });
-      expect(state.context).toEqual({ contextType: 'performer' });
-    });
-  });
-
-  describe('isTokenExpiringSoon', () => {
-    it('returns true when no token expiry is set', () => {
-      clearAuthState();
-      expect(isTokenExpiringSoon()).toBe(true);
-    });
-
-    it('returns true when token is expired', () => {
-      const pastTime = Date.now() - 10000; // 10 seconds ago
-      setAuthState({
-        isAuthenticated: true,
-        token: 'token',
-        tokenExpiry: pastTime,
-      });
-
-      expect(isTokenExpiringSoon()).toBe(true);
-    });
-
-    it('returns true when token expires within buffer time', () => {
-      const soonExpiry = Date.now() + (2 * 60 * 1000); // 2 minutes from now
-      setAuthState({
-        isAuthenticated: true,
-        token: 'token',
-        tokenExpiry: soonExpiry,
-      });
-
-      // Default buffer is 5 minutes, so 2 minutes is within buffer
-      expect(isTokenExpiringSoon()).toBe(true);
-    });
-
-    it('returns false when token has plenty of time left', () => {
-      const futureExpiry = Date.now() + (30 * 60 * 1000); // 30 minutes from now
-      setAuthState({
-        isAuthenticated: true,
-        token: 'token',
-        tokenExpiry: futureExpiry,
-      });
-
-      expect(isTokenExpiringSoon()).toBe(false);
-    });
-
-    it('accepts custom buffer time', () => {
-      const expiry = Date.now() + (10 * 60 * 1000); // 10 minutes from now
-      setAuthState({
-        isAuthenticated: true,
-        token: 'token',
-        tokenExpiry: expiry,
-      });
-
-      // With 5 minute buffer (default), should be fine
-      expect(isTokenExpiringSoon(5 * 60 * 1000)).toBe(false);
-
-      // With 15 minute buffer, should be expiring soon
-      expect(isTokenExpiringSoon(15 * 60 * 1000)).toBe(true);
-    });
-  });
-
-  describe('setPermissions and getPermissions', () => {
-    it('sets permissions on auth state', () => {
-      const permissions = {
-        events: { read: true, write: false },
-        shows: { read: true, write: true },
-      };
-
-      setPermissions(permissions);
-
-      const state = get(auth);
-      expect(state.permissions).toEqual(permissions);
-    });
-
-    it('getPermissions returns current permissions', () => {
-      const permissions = {
-        events: { read: true },
-      };
-
-      setPermissions(permissions);
-
-      expect(getPermissions()).toEqual(permissions);
-    });
-
-    it('getPermissions returns null when no permissions set', () => {
-      clearAuthState();
-      expect(getPermissions()).toBe(null);
-    });
-
-    it('preserves other state when setting permissions', () => {
-      setAuthState({
-        isAuthenticated: true,
-        token: 'test-token',
-        userDetails: { email: 'test@test.com' },
-      });
-
-      setPermissions({ events: { read: true } });
-
-      const state = get(auth);
-      expect(state.isAuthenticated).toBe(true);
-      expect(state.token).toBe('test-token');
-      expect(state.userDetails).toEqual({ email: 'test@test.com' });
-    });
-  });
-
-  describe('setContext', () => {
-    it('sets user context on auth state', () => {
-      const context = {
-        contextType: 'performer',
-        performerId: 'perf-123',
-      };
-
-      setContext(context);
-
-      const state = get(auth);
-      expect(state.context).toEqual(context);
-    });
-
-    it('preserves other state when setting context', () => {
-      setAuthState({
-        isAuthenticated: true,
-        token: 'test-token',
-        permissions: { events: { read: true } },
-      });
-
-      setContext({ contextType: 'performer' });
-
-      const state = get(auth);
-      expect(state.isAuthenticated).toBe(true);
-      expect(state.token).toBe('test-token');
-      expect(state.permissions).toEqual({ events: { read: true } });
-    });
-
-    it('can update existing context', () => {
-      setContext({ contextType: 'performer', performerId: 'old' });
-      setContext({ contextType: 'performer', performerId: 'new' });
-
-      const state = get(auth);
-      expect(state.context.performerId).toBe('new');
-    });
-  });
-
-  describe('hasPermission', () => {
-    it('returns false when no permissions are set', () => {
-      clearAuthState();
-      expect(hasPermission('events', 'read')).toBe(false);
-    });
-
-    it('returns true when permission exists and is true', () => {
-      setPermissions({
-        events: { read: true, write: false },
-      });
-
-      expect(hasPermission('events', 'read')).toBe(true);
-    });
-
-    it('returns false when permission exists and is false', () => {
-      setPermissions({
-        events: { read: true, write: false },
-      });
-
-      expect(hasPermission('events', 'write')).toBe(false);
-    });
-
-    it('returns false when category does not exist', () => {
-      setPermissions({
-        events: { read: true },
-      });
-
-      expect(hasPermission('shows', 'read')).toBe(false);
-    });
-
-    it('returns false when permission does not exist in category', () => {
-      setPermissions({
-        events: { read: true },
-      });
-
-      expect(hasPermission('events', 'delete')).toBe(false);
-    });
-
-    it('works with nested permission categories', () => {
-      setPermissions({
-        events: { read: true, write: true },
-        shows: { read: true, write: false, delete: false },
-        admin: { read: false },
-      });
-
-      expect(hasPermission('events', 'read')).toBe(true);
-      expect(hasPermission('events', 'write')).toBe(true);
-      expect(hasPermission('shows', 'read')).toBe(true);
-      expect(hasPermission('shows', 'write')).toBe(false);
-      expect(hasPermission('admin', 'read')).toBe(false);
-    });
-  });
-
-  describe('isPerformer derived store', () => {
-    it('returns true when context type is performer', () => {
-      setContext({ contextType: 'performer' });
-
-      expect(get(isPerformer)).toBe(true);
-    });
-
-    it('returns true when user is authenticated (fallback)', () => {
-      setAuthState({
-        isAuthenticated: true,
-        token: 'token',
-        userDetails: null,
-      });
-
-      expect(get(isPerformer)).toBe(true);
-    });
-
-    it('returns false when not authenticated and no performer context', () => {
-      clearAuthState();
-
-      expect(get(isPerformer)).toBe(false);
-    });
-
-    it('updates reactively when context changes', () => {
-      const values = [];
-      const unsubscribe = isPerformer.subscribe((value) => {
-        values.push(value);
-      });
-
-      clearAuthState();
-      setContext({ contextType: 'performer' });
-      setContext({ contextType: 'staff' });
-      setAuthState({ isAuthenticated: true, token: 'token' });
-
-      unsubscribe();
-
-      // false (initial), true (performer context), false (staff context, not authenticated), true (authenticated)
-      expect(values).toContain(false);
-      expect(values).toContain(true);
-    });
-  });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { get } from 'svelte/store';
+import { auth, setAuthState, clearAuthState, initializeAuthState } from './auth';
+
+describe('auth store', () => {
+  beforeEach(() => {
+    // Reset auth state before each test
+    clearAuthState();
+    // Clear cookies
+    Object.defineProperty(document, 'cookie', {
+      writable: true,
+      value: '',
+    });
+  });
+
+  describe('initial state', () => {
+    it('starts with isAuthenticated as false', () => {
+      expect(get(auth).isAuthenticated).toBe(false);
+    });
+
+    it('starts with token as null', () => {
+      expect(get(auth).token).toBe(null);
+    });
+
+    it('starts with userDetails as null', () => {
+      expect(get(auth).userDetails).toBe(null);
+    });
+  });
+
+  describe('setAuthState', () => {
+    it('sets authentication state', () => {
+      setAuthState({
+        isAuthenticated: true,
+        token: 'test-token',
+        userDetails: { email: 'test@test.com' },
+      });
+
+      const state = get(auth);
+      expect(state.isAuthenticated).toBe(true);
+      expect(state.token).toBe('test-token');
+      expect(state.userDetails).toEqual({ email: 'test@test.com' });
+    });
+
+    it('can update partial state', () => {
+      setAuthState({ isAuthenticated: true, token: 'token1', userDetails: null });
+      setAuthState({ isAuthenticated: true, token: 'token2', userDetails: { name: 'User' } });
+
+      const state = get(auth);
+      expect(state.token).toBe('token2');
+      expect(state.userDetails).toEqual({ name: 'User' });
+    });
+  });
+
+  describe('clearAuthState', () => {
+    it('clears authentication state', () => {
+      setAuthState({
+        isAuthenticated: true,
+        token: 'test-token',
+        userDetails: { email: 'test@test.com' },
+      });
+
+      clearAuthState();
+
+      const state = get(auth);
+      expect(state.isAuthenticated).toBe(false);
+      expect(state.token).toBe(null);
+      expect(state.userDetails).toBe(null);
+    });
+  });
+
+  describe('initializeAuthState', () => {
+    it('does nothing when no performer_token cookie exists', () => {
+      Object.defineProperty(document, 'cookie', {
+        writable: true,
+        value: '',
+      });
+
+      initializeAuthState();
+
+      const state = get(auth);
+      expect(state.isAuthenticated).toBe(false);
+    });
+
+    it('sets auth state from performer_token cookie', () => {
+      Object.defineProperty(document, 'cookie', {
+        writable: true,
+        value: 'performer_token=my-token',
+      });
+
+      initializeAuthState();
+
+      const state = get(auth);
+      expect(state.isAuthenticated).toBe(true);
+      expect(state.token).toBe('my-token');
+    });
+
+    it('parses userDetails cookie when present', () => {
+      const userDetails = JSON.stringify({ email: 'test@test.com', firstName: 'Test' });
+      Object.defineProperty(document, 'cookie', {
+        writable: true,
+        value: `performer_token=my-token; userDetails=${encodeURIComponent(userDetails)}`,
+      });
+
+      initializeAuthState();
+
+      const state = get(auth);
+      expect(state.userDetails).toEqual({ email: 'test@test.com', firstName: 'Test' });
+    });
+
+    it('handles missing userDetails cookie', () => {
+      Object.defineProperty(document, 'cookie', {
+        writable: true,
+        value: 'performer_token=my-token',
+      });
+
+      initializeAuthState();
+
+      const state = get(auth);
+      expect(state.isAuthenticated).toBe(true);
+      expect(state.userDetails).toBe(null);
+    });
+  });
+
+  describe('store subscription', () => {
+    it('can subscribe to auth changes', () => {
+      const values = [];
+      const unsubscribe = auth.subscribe((value) => {
+        values.push(value.isAuthenticated);
+      });
+
+      setAuthState({ isAuthenticated: true, token: 'token', userDetails: null });
+      clearAuthState();
+
+      unsubscribe();
+
+      expect(values).toEqual([false, true, false]);
+    });
+  });
+});

package/dist/stores/createFormStore.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @typedef {Object} FormStoreOptions
+ * @property {Object} initialData - Initial form data
+ * @property {string} [endpoint] - API endpoint for saving
+ * @property {string} [successMessage] - Message to show on success
+ * @property {string} [errorMessage] - Message to show on error
+ * @property {Function} [validate] - Validation function returning { isValid, errors }
+ * @property {Function} [transformData] - Transform data before saving
+ * @property {Function} [onSuccess] - Callback after successful save
+ * @property {Function} [onError] - Callback after error
+ * @property {boolean} [showToasts=true] - Show toast notifications
+ */
+/**
+ * Creates a comprehensive form store with state management, dirty tracking,
+ * validation, and save handling.
+ *
+ * @param {FormStoreOptions} options - Configuration options
+ * @returns {Object} Form store with all state and handlers
+ *
+ * @example
+ * const form = createFormStore({
+ *   initialData: { name: '', email: '' },
+ *   endpoint: '/api/profile',
+ *   validate: (data) => {
+ *     const errors = {};
+ *     if (!data.name) errors.name = 'Name is required';
+ *     return { isValid: Object.keys(errors).length === 0, errors };
+ *   }
+ * });
+ *
+ * // In Svelte component:
+ * <input bind:value={$form.data.name} on:input={form.checkDirty} />
+ * <button on:click={form.submit} disabled={$form.isLoading}>Save</button>
+ */
+export function createFormStore(options?: FormStoreOptions): Object;
+export type FormStoreOptions = {
+    /**
+     * - Initial form data
+     */
+    initialData: Object;
+    /**
+     * - API endpoint for saving
+     */
+    endpoint?: string | undefined;
+    /**
+     * - Message to show on success
+     */
+    successMessage?: string | undefined;
+    /**
+     * - Message to show on error
+     */
+    errorMessage?: string | undefined;
+    /**
+     * - Validation function returning { isValid, errors }
+     */
+    validate?: Function | undefined;
+    /**
+     * - Transform data before saving
+     */
+    transformData?: Function | undefined;
+    /**
+     * - Callback after successful save
+     */
+    onSuccess?: Function | undefined;
+    /**
+     * - Callback after error
+     */
+    onError?: Function | undefined;
+    /**
+     * - Show toast notifications
+     */
+    showToasts?: boolean | undefined;
+};
+//# sourceMappingURL=createFormStore.d.ts.map

package/dist/stores/createFormStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFormStore.d.ts","sourceRoot":"","sources":["../../src/lib/stores/createFormStore.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,0CAlBW,gBAAgB,GACd,MAAM,CA4WlB;;;;;iBA5Xa,MAAM"}