@getmicdrop/svelte-components 5.17.3 → 5.17.4

package/dist/schemas/__tests__/common.test.js

@@ -0,0 +1,340 @@
+import { describe, expect, it } from 'vitest';
+import { addressSchema, dateSchema, emailSchema, futureDateSchema, nonNegativeIntSchema, numberRange, optionalString, percentageSchema, phoneSchema, positiveIntSchema, priceSchema, requiredString, stringToInt, stringToNumber, timezoneSchema, urlSchema, usStateSchema, uuidSchema, zipCodeSchema, } from '../common';
+describe('emailSchema', () => {
+    it('accepts valid email', () => {
+        const result = emailSchema.safeParse('test@example.com');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toBe('test@example.com');
+        }
+    });
+    it('lowercases and trims email', () => {
+        const result = emailSchema.safeParse('  TEST@EXAMPLE.COM  ');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toBe('test@example.com');
+        }
+    });
+    it('rejects invalid email', () => {
+        const result = emailSchema.safeParse('invalid-email');
+        expect(result.success).toBe(false);
+    });
+    it('rejects empty string', () => {
+        const result = emailSchema.safeParse('');
+        expect(result.success).toBe(false);
+    });
+});
+describe('phoneSchema', () => {
+    it('accepts valid US phone number', () => {
+        const result = phoneSchema.safeParse('(555) 123-4567');
+        expect(result.success).toBe(true);
+    });
+    it('strips non-digit characters', () => {
+        const result = phoneSchema.safeParse('555-123-4567');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toBe('5551234567');
+        }
+    });
+    it('accepts empty string as optional', () => {
+        const result = phoneSchema.safeParse('');
+        expect(result.success).toBe(true);
+    });
+});
+describe('urlSchema', () => {
+    it('accepts valid URL', () => {
+        const result = urlSchema.safeParse('https://example.com');
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid URL', () => {
+        const result = urlSchema.safeParse('not-a-url');
+        expect(result.success).toBe(false);
+    });
+    it('accepts empty string as optional', () => {
+        const result = urlSchema.safeParse('');
+        expect(result.success).toBe(true);
+    });
+});
+describe('uuidSchema', () => {
+    it('accepts valid UUID', () => {
+        const result = uuidSchema.safeParse('550e8400-e29b-41d4-a716-446655440000');
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid UUID', () => {
+        const result = uuidSchema.safeParse('not-a-uuid');
+        expect(result.success).toBe(false);
+    });
+});
+describe('positiveIntSchema', () => {
+    it('accepts positive integer', () => {
+        const result = positiveIntSchema.safeParse(5);
+        expect(result.success).toBe(true);
+    });
+    it('rejects zero', () => {
+        const result = positiveIntSchema.safeParse(0);
+        expect(result.success).toBe(false);
+    });
+    it('rejects negative', () => {
+        const result = positiveIntSchema.safeParse(-1);
+        expect(result.success).toBe(false);
+    });
+    it('rejects float', () => {
+        const result = positiveIntSchema.safeParse(1.5);
+        expect(result.success).toBe(false);
+    });
+});
+describe('nonNegativeIntSchema', () => {
+    it('accepts zero', () => {
+        const result = nonNegativeIntSchema.safeParse(0);
+        expect(result.success).toBe(true);
+    });
+    it('accepts positive integer', () => {
+        const result = nonNegativeIntSchema.safeParse(5);
+        expect(result.success).toBe(true);
+    });
+    it('rejects negative', () => {
+        const result = nonNegativeIntSchema.safeParse(-1);
+        expect(result.success).toBe(false);
+    });
+});
+describe('priceSchema', () => {
+    it('accepts valid price', () => {
+        const result = priceSchema.safeParse(25.99);
+        expect(result.success).toBe(true);
+    });
+    it('rounds to 2 decimal places', () => {
+        const result = priceSchema.safeParse(25.999);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toBe(26);
+        }
+    });
+    it('accepts zero', () => {
+        const result = priceSchema.safeParse(0);
+        expect(result.success).toBe(true);
+    });
+    it('rejects price over 10000', () => {
+        const result = priceSchema.safeParse(10001);
+        expect(result.success).toBe(false);
+    });
+});
+describe('percentageSchema', () => {
+    it('accepts valid percentage', () => {
+        const result = percentageSchema.safeParse(50);
+        expect(result.success).toBe(true);
+    });
+    it('accepts 0', () => {
+        const result = percentageSchema.safeParse(0);
+        expect(result.success).toBe(true);
+    });
+    it('accepts 100', () => {
+        const result = percentageSchema.safeParse(100);
+        expect(result.success).toBe(true);
+    });
+    it('rejects over 100', () => {
+        const result = percentageSchema.safeParse(101);
+        expect(result.success).toBe(false);
+    });
+});
+describe('dateSchema', () => {
+    it('accepts Date object', () => {
+        const date = new Date('2025-01-01');
+        const result = dateSchema.safeParse(date);
+        expect(result.success).toBe(true);
+    });
+    it('accepts ISO string', () => {
+        const result = dateSchema.safeParse('2025-01-01T00:00:00Z');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toBeInstanceOf(Date);
+        }
+    });
+    it('rejects invalid date string', () => {
+        const result = dateSchema.safeParse('not-a-date');
+        expect(result.success).toBe(false);
+    });
+});
+describe('futureDateSchema', () => {
+    it('accepts future date', () => {
+        const futureDate = new Date();
+        futureDate.setFullYear(futureDate.getFullYear() + 1);
+        const result = futureDateSchema.safeParse(futureDate);
+        expect(result.success).toBe(true);
+    });
+    it('rejects past date', () => {
+        const pastDate = new Date('2020-01-01');
+        const result = futureDateSchema.safeParse(pastDate);
+        expect(result.success).toBe(false);
+    });
+});
+describe('timezoneSchema', () => {
+    it('accepts valid timezone', () => {
+        const result = timezoneSchema.safeParse('America/New_York');
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid timezone', () => {
+        const result = timezoneSchema.safeParse('Invalid/Timezone');
+        expect(result.success).toBe(false);
+    });
+    it('rejects empty string', () => {
+        const result = timezoneSchema.safeParse('');
+        expect(result.success).toBe(false);
+    });
+});
+describe('usStateSchema', () => {
+    it('accepts valid state code', () => {
+        const result = usStateSchema.safeParse('CA');
+        expect(result.success).toBe(true);
+    });
+    it('uppercases state code', () => {
+        const result = usStateSchema.safeParse('ca');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toBe('CA');
+        }
+    });
+    it('rejects invalid length', () => {
+        const result = usStateSchema.safeParse('California');
+        expect(result.success).toBe(false);
+    });
+});
+describe('zipCodeSchema', () => {
+    it('accepts 5-digit zip', () => {
+        const result = zipCodeSchema.safeParse('12345');
+        expect(result.success).toBe(true);
+    });
+    it('accepts zip+4', () => {
+        const result = zipCodeSchema.safeParse('12345-6789');
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid zip', () => {
+        const result = zipCodeSchema.safeParse('1234');
+        expect(result.success).toBe(false);
+    });
+});
+describe('addressSchema', () => {
+    it('accepts valid address', () => {
+        const result = addressSchema.safeParse({
+            street: '123 Main St',
+            city: 'San Francisco',
+            state: 'CA',
+            zipCode: '94102',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('defaults country to US', () => {
+        const result = addressSchema.safeParse({
+            street: '123 Main St',
+            city: 'San Francisco',
+            state: 'CA',
+            zipCode: '94102',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.country).toBe('US');
+        }
+    });
+    it('rejects missing required fields', () => {
+        const result = addressSchema.safeParse({
+            street: '123 Main St',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('requiredString', () => {
+    it('creates schema that accepts valid string', () => {
+        const schema = requiredString(100, 'Name');
+        const result = schema.safeParse('John');
+        expect(result.success).toBe(true);
+    });
+    it('rejects empty string', () => {
+        const schema = requiredString(100, 'Name');
+        const result = schema.safeParse('');
+        expect(result.success).toBe(false);
+    });
+    it('rejects string over max length', () => {
+        const schema = requiredString(5, 'Name');
+        const result = schema.safeParse('Too Long');
+        expect(result.success).toBe(false);
+    });
+    it('trims whitespace', () => {
+        const schema = requiredString(100, 'Name');
+        const result = schema.safeParse('  John  ');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toBe('John');
+        }
+    });
+});
+describe('optionalString', () => {
+    it('accepts valid string', () => {
+        const schema = optionalString(100, 'Bio');
+        const result = schema.safeParse('Hello');
+        expect(result.success).toBe(true);
+    });
+    it('accepts empty string', () => {
+        const schema = optionalString(100, 'Bio');
+        const result = schema.safeParse('');
+        expect(result.success).toBe(true);
+    });
+    it('accepts undefined', () => {
+        const schema = optionalString(100, 'Bio');
+        const result = schema.safeParse(undefined);
+        expect(result.success).toBe(true);
+    });
+});
+describe('numberRange', () => {
+    it('accepts number in range', () => {
+        const schema = numberRange(1, 10, 'Quantity');
+        const result = schema.safeParse(5);
+        expect(result.success).toBe(true);
+    });
+    it('rejects number below min', () => {
+        const schema = numberRange(1, 10, 'Quantity');
+        const result = schema.safeParse(0);
+        expect(result.success).toBe(false);
+    });
+    it('rejects number above max', () => {
+        const schema = numberRange(1, 10, 'Quantity');
+        const result = schema.safeParse(11);
+        expect(result.success).toBe(false);
+    });
+});
+describe('stringToNumber', () => {
+    it('parses string to number', () => {
+        const schema = stringToNumber();
+        const result = schema.safeParse('123.45');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toBe(123.45);
+        }
+    });
+    it('passes through number', () => {
+        const schema = stringToNumber();
+        const result = schema.safeParse(123.45);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toBe(123.45);
+        }
+    });
+    it('rejects invalid string', () => {
+        const schema = stringToNumber();
+        const result = schema.safeParse('not-a-number');
+        expect(result.success).toBe(false);
+    });
+});
+describe('stringToInt', () => {
+    it('parses string to integer', () => {
+        const schema = stringToInt();
+        const result = schema.safeParse('123');
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toBe(123);
+        }
+    });
+    it('rejects float string', () => {
+        const schema = stringToInt();
+        const result = schema.safeParse('123.45');
+        expect(result.success).toBe(false);
+    });
+});

package/dist/schemas/__tests__/domain.test.d.ts

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

package/dist/schemas/__tests__/domain.test.d.ts.map

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

package/dist/schemas/__tests__/domain.test.js

@@ -0,0 +1,293 @@
+import { describe, expect, it } from 'vitest';
+import { eventFilterSchema, eventSchema } from '../event';
+import { performerBasicInfoSchema, performerSchema } from '../performer';
+import { promoCodeSchema } from '../promo';
+import { cartItemSchema, ticketSectionSchema, ticketTypeSchema, } from '../ticket';
+import { stageSchema, venueSchema } from '../venue';
+describe('eventSchema', () => {
+    const validEvent = {
+        title: 'Comedy Night',
+        startDateTime: new Date('2025-06-01T20:00:00'),
+        endDateTime: new Date('2025-06-01T22:00:00'),
+        timezone: 'America/Los_Angeles',
+        venueId: '550e8400-e29b-41d4-a716-446655440000',
+    };
+    it('accepts valid event', () => {
+        const result = eventSchema.safeParse(validEvent);
+        expect(result.success).toBe(true);
+    });
+    it('rejects end date before start date', () => {
+        const result = eventSchema.safeParse({
+            ...validEvent,
+            startDateTime: new Date('2025-06-01T22:00:00'),
+            endDateTime: new Date('2025-06-01T20:00:00'),
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const error = result.error.issues.find(e => e.path.includes('endDateTime'));
+            expect(error).toBeDefined();
+        }
+    });
+    it('defaults status to draft', () => {
+        const result = eventSchema.safeParse(validEvent);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.status).toBe('draft');
+        }
+    });
+    it('rejects invalid timezone', () => {
+        const result = eventSchema.safeParse({
+            ...validEvent,
+            timezone: 'Invalid/Timezone',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('eventFilterSchema', () => {
+    it('accepts empty filter', () => {
+        const result = eventFilterSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with search', () => {
+        const result = eventFilterSchema.safeParse({
+            search: 'comedy',
+            status: 'published',
+        });
+        expect(result.success).toBe(true);
+    });
+});
+describe('ticketTypeSchema', () => {
+    const validTicket = {
+        name: 'General Admission',
+        ticketType: 'paid',
+        price: 25,
+        quantity: 100,
+        minimumTickets: 1,
+        maximumTickets: 10,
+    };
+    it('accepts valid ticket', () => {
+        const result = ticketTypeSchema.safeParse(validTicket);
+        expect(result.success).toBe(true);
+    });
+    it('rejects min exceeding max', () => {
+        const result = ticketTypeSchema.safeParse({
+            ...validTicket,
+            minimumTickets: 10,
+            maximumTickets: 5,
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const error = result.error.issues.find(e => e.path.includes('minimumTickets'));
+            expect(error?.message).toBe('Minimum cannot exceed maximum');
+        }
+    });
+    it('rejects sales end before start', () => {
+        const result = ticketTypeSchema.safeParse({
+            ...validTicket,
+            salesStartDateTime: new Date('2025-06-01'),
+            salesEndDateTime: new Date('2025-05-01'),
+        });
+        expect(result.success).toBe(false);
+    });
+    it('defaults visibility to visible', () => {
+        const result = ticketTypeSchema.safeParse(validTicket);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.visibility).toBe('visible');
+        }
+    });
+});
+describe('ticketSectionSchema', () => {
+    it('accepts valid section', () => {
+        const result = ticketSectionSchema.safeParse({
+            name: 'VIP Section',
+            capacity: 50,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects zero capacity', () => {
+        const result = ticketSectionSchema.safeParse({
+            name: 'VIP Section',
+            capacity: 0,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('cartItemSchema', () => {
+    it('accepts valid cart item with UUID', () => {
+        const result = cartItemSchema.safeParse({
+            ticketTypeId: '550e8400-e29b-41d4-a716-446655440000',
+            quantity: 2,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts valid cart item with number ID', () => {
+        const result = cartItemSchema.safeParse({
+            ticketTypeId: 123,
+            quantity: 2,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects quantity over max', () => {
+        const result = cartItemSchema.safeParse({
+            ticketTypeId: 123,
+            quantity: 100,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('venueSchema', () => {
+    const validVenue = {
+        name: 'The Comedy Club',
+        address: {
+            street: '123 Main St',
+            city: 'San Francisco',
+            state: 'CA',
+            zipCode: '94102',
+        },
+        timezone: 'America/Los_Angeles',
+    };
+    it('accepts valid venue', () => {
+        const result = venueSchema.safeParse(validVenue);
+        expect(result.success).toBe(true);
+    });
+    it('rejects missing name', () => {
+        const { name, ...venueWithoutName } = validVenue;
+        const result = venueSchema.safeParse(venueWithoutName);
+        expect(result.success).toBe(false);
+    });
+    it('defaults isActive to true', () => {
+        const result = venueSchema.safeParse(validVenue);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.isActive).toBe(true);
+        }
+    });
+});
+describe('stageSchema', () => {
+    it('accepts valid stage', () => {
+        const result = stageSchema.safeParse({
+            name: 'Main Stage',
+            capacity: 200,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts stage without capacity', () => {
+        const result = stageSchema.safeParse({
+            name: 'Main Stage',
+        });
+        expect(result.success).toBe(true);
+    });
+});
+describe('performerBasicInfoSchema', () => {
+    it('accepts valid performer info', () => {
+        const result = performerBasicInfoSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Comedian',
+            email: 'john@example.com',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid email', () => {
+        const result = performerBasicInfoSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Comedian',
+            email: 'invalid-email',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('performerSchema', () => {
+    it('accepts full performer data', () => {
+        const result = performerSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Comedian',
+            email: 'john@example.com',
+            bio: 'A funny person',
+            tier: 3,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects tier over max', () => {
+        const result = performerSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Comedian',
+            email: 'john@example.com',
+            tier: 10,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('promoCodeSchema', () => {
+    it('accepts valid percent discount promo', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'SUMMER20',
+            discountType: 'percent',
+            percentAmount: 20,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts valid dollar discount promo', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'SAVE10',
+            discountType: 'dollar',
+            dollarAmount: 10,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects both discount types', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'INVALID',
+            discountType: 'percent',
+            percentAmount: 20,
+            dollarAmount: 10,
+        });
+        expect(result.success).toBe(false);
+    });
+    it('allows promo without discount if reveals hidden tickets', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'REVEAL',
+            discountType: 'percent',
+            revealHiddenTickets: true,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('requires usage limit when limited', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'LIMITED',
+            discountType: 'percent',
+            percentAmount: 20,
+            limitType: 'limited',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('accepts limited promo with usage limit', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'LIMITED100',
+            discountType: 'percent',
+            percentAmount: 20,
+            limitType: 'limited',
+            usageLimit: 100,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('uppercases promo code', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'summer20',
+            discountType: 'percent',
+            percentAmount: 20,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.code).toBe('SUMMER20');
+        }
+    });
+    it('rejects invalid promo code format', () => {
+        const result = promoCodeSchema.safeParse({
+            code: 'invalid code!',
+            discountType: 'percent',
+            percentAmount: 20,
+        });
+        expect(result.success).toBe(false);
+    });
+});

package/dist/schemas/__tests__/order.test.d.ts

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

package/dist/schemas/__tests__/order.test.d.ts.map

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