@getmicdrop/svelte-components 5.17.1 → 5.17.4

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

@@ -0,0 +1,210 @@
+import { describe, expect, it } from 'vitest';
+import { forgotPasswordSchema, loginSchema, passwordChangeSchema, passwordSchema, profileUpdateSchema, registerSchema, resetPasswordSchema, } from '../auth';
+describe('passwordSchema', () => {
+    it('accepts valid password', () => {
+        const result = passwordSchema.safeParse('SecurePass123');
+        expect(result.success).toBe(true);
+    });
+    it('rejects password too short', () => {
+        const result = passwordSchema.safeParse('Short1');
+        expect(result.success).toBe(false);
+    });
+    it('rejects password without uppercase', () => {
+        const result = passwordSchema.safeParse('securepass123');
+        expect(result.success).toBe(false);
+    });
+    it('rejects password without lowercase', () => {
+        const result = passwordSchema.safeParse('SECUREPASS123');
+        expect(result.success).toBe(false);
+    });
+    it('rejects password without number', () => {
+        const result = passwordSchema.safeParse('SecurePassword');
+        expect(result.success).toBe(false);
+    });
+});
+describe('loginSchema', () => {
+    it('accepts valid login data', () => {
+        const result = loginSchema.safeParse({
+            email: 'test@example.com',
+            password: 'anypassword',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('defaults rememberMe to false', () => {
+        const result = loginSchema.safeParse({
+            email: 'test@example.com',
+            password: 'anypassword',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.rememberMe).toBe(false);
+        }
+    });
+    it('rejects invalid email', () => {
+        const result = loginSchema.safeParse({
+            email: 'invalid',
+            password: 'anypassword',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects empty password', () => {
+        const result = loginSchema.safeParse({
+            email: 'test@example.com',
+            password: '',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('registerSchema', () => {
+    it('accepts valid registration data', () => {
+        const result = registerSchema.safeParse({
+            email: 'test@example.com',
+            password: 'SecurePass123',
+            confirmPassword: 'SecurePass123',
+            firstName: 'John',
+            lastName: 'Doe',
+            acceptTerms: true,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects mismatched passwords', () => {
+        const result = registerSchema.safeParse({
+            email: 'test@example.com',
+            password: 'SecurePass123',
+            confirmPassword: 'DifferentPass123',
+            firstName: 'John',
+            lastName: 'Doe',
+            acceptTerms: true,
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const error = result.error.issues.find(e => e.path.includes('confirmPassword'));
+            expect(error?.message).toBe('Passwords do not match');
+        }
+    });
+    it('rejects if terms not accepted', () => {
+        const result = registerSchema.safeParse({
+            email: 'test@example.com',
+            password: 'SecurePass123',
+            confirmPassword: 'SecurePass123',
+            firstName: 'John',
+            lastName: 'Doe',
+            acceptTerms: false,
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects weak password', () => {
+        const result = registerSchema.safeParse({
+            email: 'test@example.com',
+            password: 'weak',
+            confirmPassword: 'weak',
+            firstName: 'John',
+            lastName: 'Doe',
+            acceptTerms: true,
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('passwordChangeSchema', () => {
+    it('accepts valid password change data', () => {
+        const result = passwordChangeSchema.safeParse({
+            currentPassword: 'OldPassword123',
+            newPassword: 'NewSecurePass456',
+            confirmNewPassword: 'NewSecurePass456',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects if new password same as current', () => {
+        const result = passwordChangeSchema.safeParse({
+            currentPassword: 'SecurePass123',
+            newPassword: 'SecurePass123',
+            confirmNewPassword: 'SecurePass123',
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const error = result.error.issues.find(e => e.path.includes('newPassword'));
+            expect(error?.message).toBe('New password must be different from current password');
+        }
+    });
+    it('rejects mismatched confirm password', () => {
+        const result = passwordChangeSchema.safeParse({
+            currentPassword: 'OldPassword123',
+            newPassword: 'NewSecurePass456',
+            confirmNewPassword: 'DifferentPass789',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('forgotPasswordSchema', () => {
+    it('accepts valid email', () => {
+        const result = forgotPasswordSchema.safeParse({
+            email: 'test@example.com',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid email', () => {
+        const result = forgotPasswordSchema.safeParse({
+            email: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('resetPasswordSchema', () => {
+    it('accepts valid reset data', () => {
+        const result = resetPasswordSchema.safeParse({
+            token: 'valid-token-123',
+            password: 'NewSecurePass123',
+            confirmPassword: 'NewSecurePass123',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects mismatched passwords', () => {
+        const result = resetPasswordSchema.safeParse({
+            token: 'valid-token-123',
+            password: 'NewSecurePass123',
+            confirmPassword: 'DifferentPass456',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects empty token', () => {
+        const result = resetPasswordSchema.safeParse({
+            token: '',
+            password: 'NewSecurePass123',
+            confirmPassword: 'NewSecurePass123',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('profileUpdateSchema', () => {
+    it('accepts valid profile data', () => {
+        const result = profileUpdateSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Doe',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts profile with phone', () => {
+        const result = profileUpdateSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Doe',
+            phone: '555-123-4567',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts profile with bio', () => {
+        const result = profileUpdateSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Doe',
+            bio: 'A short bio about me.',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects bio over 500 characters', () => {
+        const result = profileUpdateSchema.safeParse({
+            firstName: 'John',
+            lastName: 'Doe',
+            bio: 'x'.repeat(501),
+        });
+        expect(result.success).toBe(false);
+    });
+});

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

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

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

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

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":""}