@getmicdrop/svelte-components 5.4.0 → 5.4.2

package/dist/utils/__tests__/auth.test.js

@@ -0,0 +1,431 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+
+// Mock jwt-decode before importing auth module
+vi.mock('jwt-decode', () => ({
+  jwtDecode: vi.fn(),
+}));
+
+// Mock the utils module for getPerformerToken and getCookie
+vi.mock('../utils.js', () => ({
+  getPerformerToken: vi.fn(),
+  getCookie: vi.fn(),
+  parseCookies: vi.fn(() => ({})),
+}));
+
+import { jwtDecode } from 'jwt-decode';
+import { getPerformerToken, getCookie } from '../utils.js';
+import {
+  getTokenFromCookies,
+  decodePerformerToken,
+  getDecodedToken,
+  getPerformerId,
+  getPerformerEmail,
+  getPerformerName,
+  isTokenExpired,
+  getUserDetailsFromCookie,
+  getPerformerNameWithFallback,
+  getPerformerEmailWithFallback,
+} from '../auth.js';
+
+describe('auth utilities', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getTokenFromCookies', () => {
+    it('extracts performer_token from cookie string', () => {
+      const cookieString = 'other=value; performer_token=my-jwt-token; another=thing';
+      const result = getTokenFromCookies(cookieString);
+      
+      expect(result).toBe('my-jwt-token');
+    });
+
+    it('returns null when performer_token is not present', () => {
+      const cookieString = 'other=value; something=else';
+      const result = getTokenFromCookies(cookieString);
+      
+      expect(result).toBeNull();
+    });
+
+    it('returns null for null/undefined input', () => {
+      expect(getTokenFromCookies(null)).toBeNull();
+      expect(getTokenFromCookies(undefined)).toBeNull();
+    });
+
+    it('handles cookies with equal signs in value', () => {
+      const cookieString = 'performer_token=abc=def=ghi';
+      const result = getTokenFromCookies(cookieString);
+      
+      expect(result).toBe('abc=def=ghi');
+    });
+  });
+
+  describe('decodePerformerToken', () => {
+    it('decodes a valid JWT token', () => {
+      const mockPayload = { id: 123, email: 'test@example.com' };
+      vi.mocked(jwtDecode).mockReturnValue(mockPayload);
+      
+      const result = decodePerformerToken('valid.jwt.token');
+      
+      expect(jwtDecode).toHaveBeenCalledWith('valid.jwt.token');
+      expect(result).toEqual(mockPayload);
+    });
+
+    it('returns null for null token', () => {
+      const result = decodePerformerToken(null);
+      
+      expect(result).toBeNull();
+      expect(jwtDecode).not.toHaveBeenCalled();
+    });
+
+    it('returns null for empty string', () => {
+      const result = decodePerformerToken('');
+      
+      expect(result).toBeNull();
+    });
+
+    it('returns null and logs error for invalid token', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      vi.mocked(jwtDecode).mockImplementation(() => {
+        throw new Error('Invalid token');
+      });
+      
+      const result = decodePerformerToken('invalid-token');
+      
+      expect(result).toBeNull();
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'Failed to decode performer token:',
+        expect.any(Error)
+      );
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('getDecodedToken', () => {
+    it('decodes token from cookie string', () => {
+      const mockPayload = { id: 1 };
+      vi.mocked(jwtDecode).mockReturnValue(mockPayload);
+      
+      const result = getDecodedToken('performer_token=abc123');
+      
+      expect(result).toEqual(mockPayload);
+    });
+
+    it('uses getPerformerToken when no cookie string provided', () => {
+      const mockPayload = { id: 2 };
+      vi.mocked(getPerformerToken).mockReturnValue('token-from-cookie');
+      vi.mocked(jwtDecode).mockReturnValue(mockPayload);
+      
+      const result = getDecodedToken();
+      
+      expect(getPerformerToken).toHaveBeenCalled();
+      expect(result).toEqual(mockPayload);
+    });
+  });
+
+  describe('getPerformerId', () => {
+    it('extracts id field from token', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ id: 42 });
+      
+      const result = getPerformerId('token');
+      
+      expect(result).toBe(42);
+    });
+
+    it('extracts userId field when id is not present', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ userId: 99 });
+      
+      const result = getPerformerId('token');
+      
+      expect(result).toBe(99);
+    });
+
+    it('extracts user_id field as fallback', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ user_id: 77 });
+      
+      const result = getPerformerId('token');
+      
+      expect(result).toBe(77);
+    });
+
+    it('returns null when no id field is present', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ email: 'test@test.com' });
+      
+      const result = getPerformerId('token');
+      
+      expect(result).toBeNull();
+    });
+
+    it('returns null for invalid token', () => {
+      vi.mocked(jwtDecode).mockImplementation(() => {
+        throw new Error('Invalid');
+      });
+      vi.spyOn(console, 'error').mockImplementation(() => {});
+      
+      const result = getPerformerId('bad-token');
+      
+      expect(result).toBeNull();
+    });
+
+    it('handles cookie string input', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ id: 55 });
+      
+      const result = getPerformerId('performer_token=abc; other=value');
+      
+      expect(result).toBe(55);
+    });
+  });
+
+  describe('getPerformerEmail', () => {
+    it('extracts Email field (capitalized)', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ Email: 'user@example.com' });
+      
+      const result = getPerformerEmail('token');
+      
+      expect(result).toBe('user@example.com');
+    });
+
+    it('extracts email field (lowercase)', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ email: 'user@example.com' });
+      
+      const result = getPerformerEmail('token');
+      
+      expect(result).toBe('user@example.com');
+    });
+
+    it('prefers Email over email if both present', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ 
+        Email: 'capital@example.com',
+        email: 'lower@example.com' 
+      });
+      
+      const result = getPerformerEmail('token');
+      
+      expect(result).toBe('capital@example.com');
+    });
+
+    it('returns empty string when no email field', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ id: 1 });
+      
+      const result = getPerformerEmail('token');
+      
+      expect(result).toBe('');
+    });
+
+    it('returns empty string for literal "undefined" value', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ email: 'undefined' });
+      
+      const result = getPerformerEmail('token');
+      
+      expect(result).toBe('');
+    });
+
+    it('returns empty string for literal "null" value', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ email: 'null' });
+      
+      const result = getPerformerEmail('token');
+      
+      expect(result).toBe('');
+    });
+  });
+
+  describe('getPerformerName', () => {
+    it('extracts FullName field', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ FullName: 'John Doe' });
+      
+      const result = getPerformerName('token');
+      
+      expect(result).toBe('John Doe');
+    });
+
+    it('extracts fullName field', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ fullName: 'Jane Smith' });
+      
+      const result = getPerformerName('token');
+      
+      expect(result).toBe('Jane Smith');
+    });
+
+    it('extracts full_name field', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ full_name: 'Bob Wilson' });
+      
+      const result = getPerformerName('token');
+      
+      expect(result).toBe('Bob Wilson');
+    });
+
+    it('returns empty string when no name field', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ id: 1 });
+      
+      const result = getPerformerName('token');
+      
+      expect(result).toBe('');
+    });
+
+    it('returns empty string for literal "undefined" value', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ FullName: 'undefined' });
+      
+      const result = getPerformerName('token');
+      
+      expect(result).toBe('');
+    });
+
+    it('returns empty string for literal "null" value', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ fullName: 'null' });
+      
+      const result = getPerformerName('token');
+      
+      expect(result).toBe('');
+    });
+  });
+
+  describe('isTokenExpired', () => {
+    it('returns true when token has no exp claim', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ id: 1 });
+      
+      const result = isTokenExpired('token');
+      
+      expect(result).toBe(true);
+    });
+
+    it('returns true when token is expired', () => {
+      const pastTime = Math.floor(Date.now() / 1000) - 3600; // 1 hour ago
+      vi.mocked(jwtDecode).mockReturnValue({ exp: pastTime });
+      
+      const result = isTokenExpired('token');
+      
+      expect(result).toBe(true);
+    });
+
+    it('returns false when token is not expired', () => {
+      const futureTime = Math.floor(Date.now() / 1000) + 3600; // 1 hour from now
+      vi.mocked(jwtDecode).mockReturnValue({ exp: futureTime });
+      
+      const result = isTokenExpired('token');
+      
+      expect(result).toBe(false);
+    });
+
+    it('returns true when no token provided', () => {
+      const result = isTokenExpired(null);
+      
+      expect(result).toBe(true);
+    });
+
+    it('handles token expiring exactly now as expired', () => {
+      const now = Math.floor(Date.now() / 1000);
+      vi.mocked(jwtDecode).mockReturnValue({ exp: now });
+      
+      const result = isTokenExpired('token');
+      
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('getUserDetailsFromCookie', () => {
+    it('parses userDetails from cookie string', () => {
+      const userDetails = { firstName: 'John', email: 'john@example.com' };
+      const encoded = encodeURIComponent(JSON.stringify(userDetails));
+      const cookieString = `userDetails=${encoded}`;
+      
+      const result = getUserDetailsFromCookie(cookieString);
+      
+      expect(result).toEqual(userDetails);
+    });
+
+    it('returns null when userDetails cookie not present', () => {
+      const result = getUserDetailsFromCookie('other=value');
+      
+      expect(result).toBeNull();
+    });
+
+    it('returns null for invalid JSON', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const result = getUserDetailsFromCookie('userDetails=not-valid-json');
+      
+      expect(result).toBeNull();
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+
+    it('uses getCookie when no cookie string provided', () => {
+      vi.mocked(getCookie).mockReturnValue(JSON.stringify({ firstName: 'Test' }));
+      
+      const result = getUserDetailsFromCookie();
+      
+      expect(getCookie).toHaveBeenCalledWith('userDetails');
+      expect(result).toEqual({ firstName: 'Test' });
+    });
+  });
+
+  describe('getPerformerNameWithFallback', () => {
+    it('returns name from JWT when available', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ FullName: 'JWT Name' });
+      
+      const result = getPerformerNameWithFallback('performer_token=abc');
+      
+      expect(result).toBe('JWT Name');
+    });
+
+    it('falls back to userDetails cookie when JWT has no name', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ id: 1 });
+      const userDetails = { firstName: 'Cookie Name' };
+      const encoded = encodeURIComponent(JSON.stringify(userDetails));
+      
+      const result = getPerformerNameWithFallback(`performer_token=abc; userDetails=${encoded}`);
+      
+      expect(result).toBe('Cookie Name');
+    });
+
+    it('returns empty string when neither JWT nor cookie has name', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ id: 1 });
+      
+      const result = getPerformerNameWithFallback('performer_token=abc');
+      
+      expect(result).toBe('');
+    });
+  });
+
+  describe('getPerformerEmailWithFallback', () => {
+    it('returns email from JWT when available', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ email: 'jwt@example.com' });
+      
+      const result = getPerformerEmailWithFallback('performer_token=abc');
+      
+      expect(result).toBe('jwt@example.com');
+    });
+
+    it('falls back to userDetails cookie when JWT has no email', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ id: 1 });
+      const userDetails = { email: 'cookie@example.com' };
+      const encoded = encodeURIComponent(JSON.stringify(userDetails));
+      
+      const result = getPerformerEmailWithFallback(`performer_token=abc; userDetails=${encoded}`);
+      
+      expect(result).toBe('cookie@example.com');
+    });
+
+    it('returns empty string when neither JWT nor cookie has email', () => {
+      vi.mocked(jwtDecode).mockReturnValue({ id: 1 });
+      
+      const result = getPerformerEmailWithFallback('performer_token=abc');
+      
+      expect(result).toBe('');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles malformed cookie strings gracefully', () => {
+      const result = getTokenFromCookies(';;;===;;;');
+      expect(result).toBeNull();
+    });
+
+    it('handles URL-encoded token values', () => {
+      const token = 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9';
+      const encoded = encodeURIComponent(token);
+      const result = getTokenFromCookies(`performer_token=${encoded}`);
+      
+      expect(result).toBe(encoded);
+    });
+  });
+});

package/dist/utils/__tests__/formatters.test.d.ts

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

package/dist/utils/__tests__/formatters.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.test.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/__tests__/formatters.test.ts"],"names":[],"mappings":""}

package/dist/utils/__tests__/formatters.test.js

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+import { formatCreditCardNumber, formatPhoneNumber } from '../formatters';
+describe('formatters', () => {
+    describe('formatCreditCardNumber', () => {
+        it('formats 16 digits into groups of 4 separated by spaces', () => {
+            expect(formatCreditCardNumber('1234567890123456')).toBe('1234 5678 9012 3456');
+        });
+        it('handles input with existing spaces', () => {
+            expect(formatCreditCardNumber('1234 5678 9012 3456')).toBe('1234 5678 9012 3456');
+        });
+        it('strips non-digit characters before formatting', () => {
+            expect(formatCreditCardNumber('1234-5678-9012-3456')).toBe('1234 5678 9012 3456');
+            expect(formatCreditCardNumber('1234.5678.9012.3456')).toBe('1234 5678 9012 3456');
+        });
+        it('handles partial card numbers', () => {
+            expect(formatCreditCardNumber('1234')).toBe('1234');
+            expect(formatCreditCardNumber('12345678')).toBe('1234 5678');
+            expect(formatCreditCardNumber('123456789012')).toBe('1234 5678 9012');
+        });
+        it('handles empty input', () => {
+            expect(formatCreditCardNumber('')).toBe('');
+        });
+        it('handles input with only non-digits', () => {
+            expect(formatCreditCardNumber('abcd-efgh')).toBe('');
+        });
+        it('handles mixed alphanumeric input', () => {
+            expect(formatCreditCardNumber('1a2b3c4d5e6f7g8h')).toBe('1234 5678');
+        });
+        it('handles numbers longer than 16 digits', () => {
+            expect(formatCreditCardNumber('12345678901234567890')).toBe('1234 5678 9012 3456 7890');
+        });
+        it('handles American Express format (15 digits)', () => {
+            expect(formatCreditCardNumber('371449635398431')).toBe('3714 4963 5398 431');
+        });
+    });
+    describe('formatPhoneNumber', () => {
+        it('formats 10 digits into XXX-XXX-XXXX pattern', () => {
+            expect(formatPhoneNumber('1234567890')).toBe('123-456-7890');
+        });
+        it('handles input with existing dashes', () => {
+            expect(formatPhoneNumber('123-456-7890')).toBe('123-456-7890');
+        });
+        it('strips non-digit characters before formatting', () => {
+            expect(formatPhoneNumber('(123) 456-7890')).toBe('123-456-7890');
+            expect(formatPhoneNumber('123.456.7890')).toBe('123-456-7890');
+            expect(formatPhoneNumber('+1 123 456 7890')).toBe('112-345-6789'); // Note: includes country code digit
+        });
+        it('handles partial phone numbers progressively', () => {
+            expect(formatPhoneNumber('1')).toBe('1');
+            expect(formatPhoneNumber('12')).toBe('12');
+            expect(formatPhoneNumber('123')).toBe('123');
+            expect(formatPhoneNumber('1234')).toBe('123-4');
+            expect(formatPhoneNumber('12345')).toBe('123-45');
+            expect(formatPhoneNumber('123456')).toBe('123-456');
+            expect(formatPhoneNumber('1234567')).toBe('123-456-7');
+            expect(formatPhoneNumber('12345678')).toBe('123-456-78');
+            expect(formatPhoneNumber('123456789')).toBe('123-456-789');
+            expect(formatPhoneNumber('1234567890')).toBe('123-456-7890');
+        });
+        it('handles empty input', () => {
+            expect(formatPhoneNumber('')).toBe('');
+        });
+        it('handles input with only non-digits', () => {
+            expect(formatPhoneNumber('abc-def-ghij')).toBe('');
+        });
+        it('truncates numbers longer than 10 digits', () => {
+            expect(formatPhoneNumber('12345678901234')).toBe('123-456-7890');
+        });
+        it('handles mixed alphanumeric input', () => {
+            expect(formatPhoneNumber('1a2b3c4d5e6f7g8h9i0j')).toBe('123-456-7890');
+        });
+    });
+});

package/dist/utils/auth.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Auth Utilities Type Definitions
+ */
+
+export interface PerformerTokenPayload {
+  id?: number;
+  userId?: number;
+  user_id?: number;
+  FullName?: string;
+  fullName?: string;
+  full_name?: string;
+  firstName?: string;
+  first_name?: string;
+  lastName?: string;
+  last_name?: string;
+  Email?: string;
+  email?: string;
+  exp?: number;
+  iat?: number;
+  sub?: string;
+  [key: string]: unknown;
+}
+
+export interface UserDetails {
+  firstName?: string;
+  lastName?: string;
+  email?: string;
+  [key: string]: unknown;
+}
+
+// Re-exported from utils.js
+export function getPerformerToken(): string | null;
+export function getCookie(name: string): string | null;
+export function parseCookies(): Record<string, string>;
+
+// JWT utilities
+export function getTokenFromCookies(cookieString?: string): string | null;
+export function decodePerformerToken(token?: string | null): PerformerTokenPayload | null;
+export function getDecodedToken(cookieString?: string): PerformerTokenPayload | null;
+export function getPerformerId(tokenOrCookies?: string | null): number | null;
+export function getPerformerEmail(tokenOrCookies?: string | null): string;
+export function getPerformerName(tokenOrCookies?: string | null): string;
+export function isTokenExpired(tokenOrCookies?: string | null): boolean;
+export function getUserDetailsFromCookie(cookieString?: string): UserDetails | null;
+export function getPerformerNameWithFallback(cookieString?: string): string;
+export function getPerformerEmailWithFallback(cookieString?: string): string;

package/dist/utils/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/lib/utils/auth.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,mDAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAcvB;AAED;;;;GAIG;AACH,6CAHW,MAAM,GAAC,IAAI,GACT,MAAM,GAAC,IAAI,CAWvB;AAED;;;;GAIG;AACH,+CAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAOvB;AAED;;;;GAIG;AACH,gDAHW,MAAM,GAAC,IAAI,GACT,MAAM,GAAC,IAAI,CAWvB;AAED;;;;GAIG;AACH,mDAHW,MAAM,GAAC,IAAI,GACT,MAAM,CAelB;AAED;;;;GAIG;AACH,kDAHW,MAAM,GAAC,IAAI,GACT,MAAM,CAelB;AAED;;;;GAIG;AACH,gDAHW,MAAM,GAAC,IAAI,mBACT,OAAO,CAoBnB;AAED;;;;GAIG;AACH,wDAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAwBvB;AAED;;;;GAIG;AACH,4DAHW,MAAM,GACJ,MAAM,CAQlB;AAED;;;;GAIG;AACH,6DAHW,MAAM,GACJ,MAAM,CAQlB;kCA1L0D,YAAY;0BAAZ,YAAY;6BAAZ,YAAY"}