@getmicdrop/svelte-components 5.17.1 → 5.17.4

package/dist/schemas/venue.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { CAPACITY, STRING_LIMITS } from '../config';
+import { VALIDATION_MESSAGES } from '../messages';
+import { addressSchema, emailSchema, imageSchema, optionalString, phoneSchema, positiveIntSchema, requiredString, socialLinksSchema, timezoneSchema, urlSchema, } from './common';
+export const venueSchema = z.object({
+    name: requiredString(STRING_LIMITS.VENUE_NAME_MAX, 'Venue name'),
+    description: optionalString(STRING_LIMITS.VENUE_DESCRIPTION_MAX, 'Description'),
+    address: addressSchema,
+    phone: phoneSchema,
+    email: emailSchema.optional().or(z.literal('')),
+    website: urlSchema,
+    timezone: timezoneSchema,
+    capacity: positiveIntSchema
+        .max(CAPACITY.MAX_CAPACITY, VALIDATION_MESSAGES.tooLarge('Capacity', CAPACITY.MAX_CAPACITY))
+        .optional(),
+    imageUrl: imageSchema,
+    logoUrl: imageSchema,
+    socialLinks: socialLinksSchema.optional(),
+    isActive: z.boolean().default(true),
+});
+export const venueUpdateSchema = venueSchema.partial();
+export const stageSchema = z.object({
+    name: requiredString(100, 'Stage name'),
+    description: optionalString(500, 'Description'),
+    capacity: positiveIntSchema.optional(),
+    sortOrder: z.number().int().min(0).default(0),
+    isActive: z.boolean().default(true),
+});
+export const venueSettingsSchema = z.object({
+    serviceFeePercentage: z.number().min(0).max(0.15).default(0.03),
+    serviceFeeFixed: z.number().min(0).max(10).default(1.29),
+    absorbServiceFee: z.boolean().default(false),
+    allowRefunds: z.boolean().default(true),
+    refundCutoffDays: z.number().int().min(0).max(30).default(7),
+    requireApproval: z.boolean().default(false),
+    ticketTransfersEnabled: z.boolean().default(true),
+    waitlistEnabled: z.boolean().default(false),
+});
+export const venueFaqSchema = z.object({
+    question: requiredString(200, 'Question'),
+    answer: requiredString(2000, 'Answer'),
+    sortOrder: z.number().int().min(0).default(0),
+    isActive: z.boolean().default(true),
+});
+export const venueFilterSchema = z.object({
+    search: z.string().optional(),
+    isActive: z.boolean().optional(),
+    city: z.string().optional(),
+    state: z.string().optional(),
+    limit: z.number().int().positive().optional(),
+    offset: z.number().int().min(0).optional(),
+});

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, beforeEach } 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/telemetry.spec.js

@@ -73,6 +73,11 @@ vi.mock('@opentelemetry/instrumentation-user-interaction', () => ({
   },
 }));
 
+vi.mock('@opentelemetry/instrumentation', () => ({
+  registerInstrumentations: vi.fn(),
+}));
+
+
 vi.mock('@opentelemetry/context-zone', () => ({
   ZoneContextManager: class MockZoneContextManager {},
 }));

package/dist/tokens/__tests__/sizing.test.js

@@ -184,8 +184,8 @@ describe('sizing tokens', () => {
         it('half variant includes w-1/2', () => {
             expect(buttonSizes.half).toContain('w-1/2');
         });
-        it('has exactly 10 size variants', () => {
-            expect(Object.keys(buttonSizes)).toHaveLength(10);
+        it('has exactly 13 size variants', () => {
+            expect(Object.keys(buttonSizes)).toHaveLength(13);
         });
         it('landing variant has responsive height and text', () => {
             expect(buttonSizes.landing).toContain('h-12');

package/dist/tokens/sizing.d.ts

@@ -76,10 +76,15 @@ export declare const buttonSizes: {
     readonly full: "w-full h-11 px-5 text-sm";
     readonly 'full-md-auto': "w-full h-11 px-5 text-sm md:w-auto";
     readonly half: "w-1/2 h-10 px-4 text-sm";
+    readonly 'icon-sm': "w-9 h-9 p-0";
+    readonly 'icon-md': "w-10 h-10 p-0";
+    readonly 'icon-lg': "w-11 h-11 p-0";
     readonly landing: "h-12 sm:h-14 px-6 sm:px-8 text-base sm:text-lg";
 };
 /**
  * Icon-only button sizes - padding only, no text.
+ * For variant="icon" (transparent). For other variants with icon-only,
+ * use the square sizes in buttonSizes (icon-sm, icon-md, icon-lg).
  */
 export declare const buttonIconSizes: {
     readonly xs: "p-1.5";

package/dist/tokens/sizing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sizing.d.ts","sourceRoot":"","sources":["../../src/lib/tokens/sizing.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;CAIjB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;CAInB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,cAAc,CAAC;AACxD,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,gBAAgB,CAAC;AAM5D;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;CAMZ,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,SAAS,CAAC;AAM9C;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;CAKb,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,UAAU,CAItE,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,UAAU,CAAC;AAChD,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAM3D;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;CAMhB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,aAAa,CAAC;AAMtD;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;CAYd,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;CAKlB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;CAKtB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,eAAe;;;;CAIlB,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,WAAW,CAAC;AAClD,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,eAAe,CAAC;AAC1D,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,iBAAiB,CAAC;AAC9D,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,mBAAmB,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,eAAe,CAAC"}
+{"version":3,"file":"sizing.d.ts","sourceRoot":"","sources":["../../src/lib/tokens/sizing.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;CAIjB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;CAInB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,cAAc,CAAC;AACxD,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,gBAAgB,CAAC;AAM5D;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;CAMZ,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,SAAS,CAAC;AAM9C;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;CAKb,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,UAAU,CAItE,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,MAAM,OAAO,UAAU,CAAC;AAChD,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAM3D;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;CAMhB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,aAAa,CAAC;AAMtD;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;CAgBd,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;CAKlB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;CAKtB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,eAAe;;;;CAIlB,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,WAAW,CAAC;AAClD,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,eAAe,CAAC;AAC1D,MAAM,MAAM,gBAAgB,GAAG,MAAM,OAAO,iBAAiB,CAAC;AAC9D,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,mBAAmB,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,eAAe,CAAC"}

package/dist/tokens/sizing.js

@@ -89,11 +89,17 @@ export const buttonSizes = {
     full: 'w-full h-11 px-5 text-sm',
     'full-md-auto': 'w-full h-11 px-5 text-sm md:w-auto',
     half: 'w-1/2 h-10 px-4 text-sm',
+    // Square icon-only sizes — for any variant used as an icon button (e.g. +/- controls)
+    'icon-sm': 'w-9 h-9 p-0',
+    'icon-md': 'w-10 h-10 p-0',
+    'icon-lg': 'w-11 h-11 p-0',
     // Landing page hero buttons - taller with larger text
     landing: 'h-12 sm:h-14 px-6 sm:px-8 text-base sm:text-lg',
 };
 /**
  * Icon-only button sizes - padding only, no text.
+ * For variant="icon" (transparent). For other variants with icon-only,
+ * use the square sizes in buttonSizes (icon-sm, icon-md, icon-lg).
  */
 export const buttonIconSizes = {
     xs: 'p-1.5',

package/dist/utils/haptic.spec.d.ts

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