@getmicdrop/svelte-components 5.17.1 → 5.17.4

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

@@ -0,0 +1,325 @@
+import { describe, expect, it } from 'vitest';
+import { teamInviteSchema, teamMemberSchema, teamMemberUpdateSchema, userFilterSchema, userPreferencesSchema, userProfileSchema, userProfileUpdateSchema, userRoleSchema, } from '../user';
+describe('userRoleSchema', () => {
+    it('accepts valid roles', () => {
+        const roles = ['owner', 'admin', 'manager', 'staff', 'viewer'];
+        roles.forEach(role => {
+            const result = userRoleSchema.safeParse(role);
+            expect(result.success).toBe(true);
+        });
+    });
+    it('rejects invalid role', () => {
+        const result = userRoleSchema.safeParse('superadmin');
+        expect(result.success).toBe(false);
+    });
+});
+describe('userProfileSchema', () => {
+    const validProfile = {
+        firstName: 'John',
+        lastName: 'Doe',
+        email: 'john@example.com',
+    };
+    it('accepts valid profile', () => {
+        const result = userProfileSchema.safeParse(validProfile);
+        expect(result.success).toBe(true);
+    });
+    it('accepts profile with phone', () => {
+        const result = userProfileSchema.safeParse({
+            ...validProfile,
+            phone: '555-123-4567',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts profile with bio', () => {
+        const result = userProfileSchema.safeParse({
+            ...validProfile,
+            bio: 'A comedy venue owner from San Francisco',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects missing first name', () => {
+        const { firstName, ...profileWithoutFirst } = validProfile;
+        const result = userProfileSchema.safeParse(profileWithoutFirst);
+        expect(result.success).toBe(false);
+    });
+    it('rejects missing last name', () => {
+        const { lastName, ...profileWithoutLast } = validProfile;
+        const result = userProfileSchema.safeParse(profileWithoutLast);
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid email', () => {
+        const result = userProfileSchema.safeParse({
+            ...validProfile,
+            email: 'invalid-email',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects bio over 500 characters', () => {
+        const result = userProfileSchema.safeParse({
+            ...validProfile,
+            bio: 'x'.repeat(501),
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('userProfileUpdateSchema', () => {
+    it('accepts empty update (all fields optional)', () => {
+        const result = userProfileUpdateSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    it('accepts partial update', () => {
+        const result = userProfileUpdateSchema.safeParse({
+            firstName: 'Jane',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts full update', () => {
+        const result = userProfileUpdateSchema.safeParse({
+            firstName: 'Jane',
+            lastName: 'Smith',
+            email: 'jane@example.com',
+            phone: '555-987-6543',
+            bio: 'Updated bio',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid email even when optional', () => {
+        const result = userProfileUpdateSchema.safeParse({
+            email: 'invalid-email',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('userPreferencesSchema', () => {
+    it('accepts empty preferences (uses defaults)', () => {
+        const result = userPreferencesSchema.safeParse({});
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.emailNotifications).toBe(true);
+            expect(result.data.smsNotifications).toBe(false);
+            expect(result.data.marketingEmails).toBe(false);
+            expect(result.data.language).toBe('en');
+        }
+    });
+    it('accepts custom preferences', () => {
+        const result = userPreferencesSchema.safeParse({
+            emailNotifications: false,
+            smsNotifications: true,
+            marketingEmails: true,
+            timezone: 'America/Los_Angeles',
+            language: 'es',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.emailNotifications).toBe(false);
+            expect(result.data.smsNotifications).toBe(true);
+            expect(result.data.marketingEmails).toBe(true);
+            expect(result.data.timezone).toBe('America/Los_Angeles');
+            expect(result.data.language).toBe('es');
+        }
+    });
+    it('accepts partial preferences', () => {
+        const result = userPreferencesSchema.safeParse({
+            smsNotifications: true,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.smsNotifications).toBe(true);
+            expect(result.data.emailNotifications).toBe(true);
+        }
+    });
+});
+describe('teamMemberSchema', () => {
+    const validMember = {
+        email: 'team@example.com',
+        firstName: 'Team',
+        lastName: 'Member',
+        role: 'staff',
+    };
+    it('accepts valid team member', () => {
+        const result = teamMemberSchema.safeParse(validMember);
+        expect(result.success).toBe(true);
+    });
+    it('accepts team member with venue IDs', () => {
+        const result = teamMemberSchema.safeParse({
+            ...validMember,
+            venueIds: [1, 2, 3],
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts all roles', () => {
+        const roles = ['owner', 'admin', 'manager', 'staff', 'viewer'];
+        roles.forEach(role => {
+            const result = teamMemberSchema.safeParse({
+                ...validMember,
+                role,
+            });
+            expect(result.success).toBe(true);
+        });
+    });
+    it('rejects missing email', () => {
+        const { email, ...memberWithoutEmail } = validMember;
+        const result = teamMemberSchema.safeParse(memberWithoutEmail);
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid role', () => {
+        const result = teamMemberSchema.safeParse({
+            ...validMember,
+            role: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid venue ID', () => {
+        const result = teamMemberSchema.safeParse({
+            ...validMember,
+            venueIds: [-1, 0],
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('teamMemberUpdateSchema', () => {
+    it('accepts empty update', () => {
+        const result = teamMemberUpdateSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    it('accepts partial update with role', () => {
+        const result = teamMemberUpdateSchema.safeParse({
+            role: 'manager',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts partial update with venue IDs', () => {
+        const result = teamMemberUpdateSchema.safeParse({
+            venueIds: [4, 5, 6],
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid role', () => {
+        const result = teamMemberUpdateSchema.safeParse({
+            role: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('teamInviteSchema', () => {
+    const validInvite = {
+        email: 'newmember@example.com',
+        role: 'staff',
+        venueIds: [1],
+    };
+    it('accepts valid invite', () => {
+        const result = teamInviteSchema.safeParse(validInvite);
+        expect(result.success).toBe(true);
+    });
+    it('accepts invite with message', () => {
+        const result = teamInviteSchema.safeParse({
+            ...validInvite,
+            message: 'Welcome to the team!',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts invite with multiple venues', () => {
+        const result = teamInviteSchema.safeParse({
+            ...validInvite,
+            venueIds: [1, 2, 3, 4, 5],
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects empty venueIds', () => {
+        const result = teamInviteSchema.safeParse({
+            ...validInvite,
+            venueIds: [],
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const error = result.error.issues.find(e => e.path.includes('venueIds'));
+            expect(error?.message).toBe('At least one venue must be selected');
+        }
+    });
+    it('rejects missing email', () => {
+        const { email, ...inviteWithoutEmail } = validInvite;
+        const result = teamInviteSchema.safeParse(inviteWithoutEmail);
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid email', () => {
+        const result = teamInviteSchema.safeParse({
+            ...validInvite,
+            email: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects message over 500 characters', () => {
+        const result = teamInviteSchema.safeParse({
+            ...validInvite,
+            message: 'x'.repeat(501),
+        });
+        expect(result.success).toBe(false);
+    });
+});
+describe('userFilterSchema', () => {
+    it('accepts empty filter', () => {
+        const result = userFilterSchema.safeParse({});
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with role', () => {
+        const result = userFilterSchema.safeParse({
+            role: 'admin',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with search', () => {
+        const result = userFilterSchema.safeParse({
+            search: 'john',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with pagination', () => {
+        const result = userFilterSchema.safeParse({
+            limit: 25,
+            offset: 50,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with venue and active status', () => {
+        const result = userFilterSchema.safeParse({
+            venueId: 123,
+            isActive: true,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('accepts filter with all options', () => {
+        const result = userFilterSchema.safeParse({
+            search: 'manager',
+            role: 'manager',
+            venueId: 1,
+            isActive: true,
+            limit: 10,
+            offset: 0,
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects invalid role in filter', () => {
+        const result = userFilterSchema.safeParse({
+            role: 'invalid',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects negative limit', () => {
+        const result = userFilterSchema.safeParse({
+            limit: -1,
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects negative offset', () => {
+        const result = userFilterSchema.safeParse({
+            offset: -1,
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects zero limit', () => {
+        const result = userFilterSchema.safeParse({
+            limit: 0,
+        });
+        expect(result.success).toBe(false);
+    });
+});

package/dist/schemas/auth.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const passwordSchema: z.ZodString;
+export declare const loginSchema: z.ZodObject<{
+    email: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+    password: z.ZodString;
+    rememberMe: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type LoginInput = z.infer<typeof loginSchema>;
+export declare const registerSchema: z.ZodObject<{
+    email: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+    password: z.ZodString;
+    confirmPassword: z.ZodString;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    acceptTerms: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type RegisterInput = z.infer<typeof registerSchema>;
+export declare const passwordChangeSchema: z.ZodObject<{
+    currentPassword: z.ZodString;
+    newPassword: z.ZodString;
+    confirmNewPassword: z.ZodString;
+}, z.core.$strip>;
+export type PasswordChangeInput = z.infer<typeof passwordChangeSchema>;
+export declare const forgotPasswordSchema: z.ZodObject<{
+    email: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+}, z.core.$strip>;
+export type ForgotPasswordInput = z.infer<typeof forgotPasswordSchema>;
+export declare const resetPasswordSchema: z.ZodObject<{
+    token: z.ZodString;
+    password: z.ZodString;
+    confirmPassword: z.ZodString;
+}, z.core.$strip>;
+export type ResetPasswordInput = z.infer<typeof resetPasswordSchema>;
+export declare const profileUpdateSchema: z.ZodObject<{
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    phone: z.ZodPipe<z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>, z.ZodTransform<string | undefined, string | undefined>>;
+    bio: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+}, z.core.$strip>;
+export type ProfileUpdateInput = z.infer<typeof profileUpdateSchema>;
+//# sourceMappingURL=auth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/lib/schemas/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,cAAc,aAyBxB,CAAC;AAEJ,eAAO,MAAM,WAAW;;;;iBAItB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAErD,eAAO,MAAM,cAAc;;;;;;;iBAcvB,CAAC;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE3D,eAAO,MAAM,oBAAoB;;;;iBAa7B,CAAC;AAEL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEvE,eAAO,MAAM,oBAAoB;;iBAE/B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEvE,eAAO,MAAM,mBAAmB;;;;iBAS5B,CAAC;AAEL,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAErE,eAAO,MAAM,mBAAmB;;;;;iBAS9B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/schemas/auth.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { PASSWORD } from '../config';
+import { VALIDATION_MESSAGES } from '../messages';
+import { emailSchema, phoneSchema, requiredString } from './common';
+export const passwordSchema = z
+    .string()
+    .min(PASSWORD.MIN_LENGTH, VALIDATION_MESSAGES.passwordTooShort(PASSWORD.MIN_LENGTH))
+    .max(PASSWORD.MAX_LENGTH, VALIDATION_MESSAGES.passwordTooLong(PASSWORD.MAX_LENGTH))
+    .refine(val => !PASSWORD.REQUIRE_UPPERCASE || /[A-Z]/.test(val), VALIDATION_MESSAGES.PASSWORD_NEEDS_UPPERCASE)
+    .refine(val => !PASSWORD.REQUIRE_LOWERCASE || /[a-z]/.test(val), VALIDATION_MESSAGES.PASSWORD_NEEDS_LOWERCASE)
+    .refine(val => !PASSWORD.REQUIRE_NUMBER || /[0-9]/.test(val), VALIDATION_MESSAGES.PASSWORD_NEEDS_NUMBER)
+    .refine(val => !PASSWORD.REQUIRE_SPECIAL || /[^A-Za-z0-9]/.test(val), VALIDATION_MESSAGES.PASSWORD_NEEDS_SPECIAL);
+export const loginSchema = z.object({
+    email: emailSchema,
+    password: z.string().min(1, VALIDATION_MESSAGES.REQUIRED),
+    rememberMe: z.boolean().default(false),
+});
+export const registerSchema = z
+    .object({
+    email: emailSchema,
+    password: passwordSchema,
+    confirmPassword: z.string(),
+    firstName: requiredString(50, 'First name'),
+    lastName: requiredString(50, 'Last name'),
+    acceptTerms: z.literal(true, {
+        message: VALIDATION_MESSAGES.ACCEPT_TERMS_REQUIRED,
+    }),
+})
+    .refine(data => data.password === data.confirmPassword, {
+    message: VALIDATION_MESSAGES.PASSWORDS_MUST_MATCH,
+    path: ['confirmPassword'],
+});
+export const passwordChangeSchema = z
+    .object({
+    currentPassword: z.string().min(1, VALIDATION_MESSAGES.REQUIRED),
+    newPassword: passwordSchema,
+    confirmNewPassword: z.string(),
+})
+    .refine(data => data.newPassword === data.confirmNewPassword, {
+    message: VALIDATION_MESSAGES.PASSWORDS_MUST_MATCH,
+    path: ['confirmNewPassword'],
+})
+    .refine(data => data.currentPassword !== data.newPassword, {
+    message: VALIDATION_MESSAGES.PASSWORD_SAME_AS_CURRENT,
+    path: ['newPassword'],
+});
+export const forgotPasswordSchema = z.object({
+    email: emailSchema,
+});
+export const resetPasswordSchema = z
+    .object({
+    token: z.string().min(1),
+    password: passwordSchema,
+    confirmPassword: z.string(),
+})
+    .refine(data => data.password === data.confirmPassword, {
+    message: VALIDATION_MESSAGES.PASSWORDS_MUST_MATCH,
+    path: ['confirmPassword'],
+});
+export const profileUpdateSchema = z.object({
+    firstName: requiredString(50, 'First name'),
+    lastName: requiredString(50, 'Last name'),
+    phone: phoneSchema,
+    bio: z
+        .string()
+        .max(500, VALIDATION_MESSAGES.tooLong('Bio', 500))
+        .optional()
+        .or(z.literal('')),
+});

package/dist/schemas/common.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const emailSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+export declare const phoneSchema: z.ZodPipe<z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>, z.ZodTransform<string | undefined, string | undefined>>;
+export declare const urlSchema: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+export declare const uuidSchema: z.ZodString;
+export declare const optionalUuidSchema: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+export declare const positiveIntSchema: z.ZodNumber;
+export declare const nonNegativeIntSchema: z.ZodNumber;
+export declare const nonNegativeSchema: z.ZodNumber;
+export declare const priceSchema: z.ZodPipe<z.ZodNumber, z.ZodTransform<number, number>>;
+export declare const percentageSchema: z.ZodNumber;
+export declare const dateSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>, z.ZodTransform<Date, string | Date>>;
+export declare const futureDateSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>, z.ZodTransform<Date, string | Date>>;
+export declare const optionalDateSchema: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDate, z.ZodNull]>>, z.ZodTransform<Date | null, string | Date | null | undefined>>;
+export declare const timezoneSchema: z.ZodString;
+export declare const usStateSchema: z.ZodString;
+export declare const zipCodeSchema: z.ZodString;
+export declare const addressSchema: z.ZodObject<{
+    street: z.ZodString;
+    street2: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+    city: z.ZodString;
+    state: z.ZodString;
+    zipCode: z.ZodString;
+    country: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type AddressInput = z.infer<typeof addressSchema>;
+export declare const imageFileSchema: z.ZodCustom<File, File>;
+export declare const imageSchema: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<File, File>, z.ZodNull]>>;
+export declare const socialLinksSchema: z.ZodObject<{
+    facebook: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>>;
+    instagram: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>>;
+    twitter: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>>;
+    tiktok: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>>;
+    youtube: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>>;
+    website: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>>;
+}, z.core.$strip>;
+export type SocialLinksInput = z.infer<typeof socialLinksSchema>;
+export declare function requiredString(maxLength: number, fieldName: string): z.ZodString;
+export declare function optionalString(maxLength: number, fieldName: string): z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
+export declare function numberRange(min: number, max: number, fieldName: string): z.ZodNumber;
+export declare function stringToNumber(): z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<number, string | number>>;
+export declare function stringToInt(): z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<number, string | number>>;
+//# sourceMappingURL=common.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/lib/schemas/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,WAAW,gFAYrB,CAAC;AAEJ,eAAO,MAAM,WAAW,+HAK6B,CAAC;AAEtD,eAAO,MAAM,SAAS,4DAQF,CAAC;AAErB,eAAO,MAAM,UAAU,aAAoD,CAAC;AAE5E,eAAO,MAAM,kBAAkB,4DAA0C,CAAC;AAE1E,eAAO,MAAM,iBAAiB,aAGmB,CAAC;AAElD,eAAO,MAAM,oBAAoB,aAGkB,CAAC;AAEpD,eAAO,MAAM,iBAAiB,aAEqB,CAAC;AAEpD,eAAO,MAAM,WAAW,wDAIoB,CAAC;AAE7C,eAAO,MAAM,gBAAgB,aAGuB,CAAC;AAErD,eAAO,MAAM,UAAU,+FAG8C,CAAC;AAEtE,eAAO,MAAM,gBAAgB,+FAG5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,mJAO3B,CAAC;AAEL,eAAO,MAAM,cAAc,aAUe,CAAC;AAE3C,eAAO,MAAM,aAAa,aAGV,CAAC;AAEjB,eAAO,MAAM,aAAa,aAEkC,CAAC;AAE7D,eAAO,MAAM,aAAa;;;;;;;iBAiBxB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AASzD,eAAO,MAAM,eAAe,yBAYzB,CAAC;AAEJ,eAAO,MAAM,WAAW,uFAEX,CAAC;AAEd,eAAO,MAAM,iBAAiB;;;;;;;iBASlB,CAAC;AAEb,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEjE,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,eAMlE;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,8DAOlE;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,eAKtE;AAED,wBAAgB,cAAc,wGAK7B;AAED,wBAAgB,WAAW,wGAU1B"}

package/dist/schemas/common.js

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+import { FILE_LIMITS, PATTERNS, STRING_LIMITS, } from '../config';
+import { VALIDATION_MESSAGES } from '../messages';
+export const emailSchema = z
+    .string()
+    .transform(v => v.trim().toLowerCase())
+    .pipe(z
+    .string()
+    .min(1, VALIDATION_MESSAGES.REQUIRED)
+    .max(STRING_LIMITS.EMAIL_MAX, VALIDATION_MESSAGES.tooLong('Email', STRING_LIMITS.EMAIL_MAX))
+    .email(VALIDATION_MESSAGES.INVALID_EMAIL));
+export const phoneSchema = z
+    .string()
+    .regex(PATTERNS.PHONE, VALIDATION_MESSAGES.INVALID_PHONE)
+    .optional()
+    .or(z.literal(''))
+    .transform(v => v?.replace(/\D/g, '') || undefined);
+export const urlSchema = z
+    .string()
+    .max(STRING_LIMITS.URL_MAX, VALIDATION_MESSAGES.tooLong('URL', STRING_LIMITS.URL_MAX))
+    .url(VALIDATION_MESSAGES.INVALID_URL)
+    .optional()
+    .or(z.literal(''));
+export const uuidSchema = z.string().uuid(VALIDATION_MESSAGES.INVALID_UUID);
+export const optionalUuidSchema = uuidSchema.optional().or(z.literal(''));
+export const positiveIntSchema = z
+    .number()
+    .int(VALIDATION_MESSAGES.MUST_BE_INTEGER)
+    .positive(VALIDATION_MESSAGES.MUST_BE_POSITIVE);
+export const nonNegativeIntSchema = z
+    .number()
+    .int(VALIDATION_MESSAGES.MUST_BE_INTEGER)
+    .min(0, VALIDATION_MESSAGES.MUST_BE_NON_NEGATIVE);
+export const nonNegativeSchema = z
+    .number()
+    .min(0, VALIDATION_MESSAGES.MUST_BE_NON_NEGATIVE);
+export const priceSchema = z
+    .number()
+    .min(0, VALIDATION_MESSAGES.MUST_BE_NON_NEGATIVE)
+    .max(10000, VALIDATION_MESSAGES.PRICE_TOO_HIGH)
+    .transform(v => Math.round(v * 100) / 100);
+export const percentageSchema = z
+    .number()
+    .min(0, VALIDATION_MESSAGES.MUST_BE_NON_NEGATIVE)
+    .max(100, VALIDATION_MESSAGES.PERCENTAGE_TOO_HIGH);
+export const dateSchema = z
+    .union([z.string(), z.date()])
+    .transform(v => (typeof v === 'string' ? new Date(v) : v))
+    .refine(d => !isNaN(d.getTime()), VALIDATION_MESSAGES.INVALID_DATE);
+export const futureDateSchema = dateSchema.refine(d => d > new Date(), VALIDATION_MESSAGES.DATE_MUST_BE_FUTURE);
+export const optionalDateSchema = z
+    .union([z.string(), z.date(), z.null()])
+    .optional()
+    .transform(v => {
+    if (!v)
+        return null;
+    const date = typeof v === 'string' ? new Date(v) : v;
+    return isNaN(date.getTime()) ? null : date;
+});
+export const timezoneSchema = z
+    .string()
+    .min(1, VALIDATION_MESSAGES.REQUIRED)
+    .refine(tz => {
+    try {
+        Intl.DateTimeFormat(undefined, { timeZone: tz });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}, VALIDATION_MESSAGES.INVALID_TIMEZONE);
+export const usStateSchema = z
+    .string()
+    .length(2, VALIDATION_MESSAGES.INVALID_STATE)
+    .toUpperCase();
+export const zipCodeSchema = z
+    .string()
+    .regex(PATTERNS.ZIP_CODE, VALIDATION_MESSAGES.INVALID_ZIP);
+export const addressSchema = z.object({
+    street: z
+        .string()
+        .min(1, VALIDATION_MESSAGES.REQUIRED)
+        .max(STRING_LIMITS.ADDRESS_MAX),
+    street2: z
+        .string()
+        .max(STRING_LIMITS.ADDRESS_MAX)
+        .optional()
+        .or(z.literal('')),
+    city: z
+        .string()
+        .min(1, VALIDATION_MESSAGES.REQUIRED)
+        .max(STRING_LIMITS.CITY_MAX),
+    state: usStateSchema,
+    zipCode: zipCodeSchema,
+    country: z.string().default('US'),
+});
+const ALLOWED_IMAGE_TYPES = [
+    'image/jpeg',
+    'image/png',
+    'image/gif',
+    'image/webp',
+];
+export const imageFileSchema = z
+    .instanceof(File)
+    .refine(file => file.size <= FILE_LIMITS.MAX_IMAGE_SIZE, VALIDATION_MESSAGES.fileTooLarge(FILE_LIMITS.MAX_IMAGE_SIZE / (1024 * 1024)))
+    .refine(file => ALLOWED_IMAGE_TYPES.includes(file.type), VALIDATION_MESSAGES.invalidFileType(ALLOWED_IMAGE_TYPES));
+export const imageSchema = z
+    .union([z.string().url(), imageFileSchema, z.null()])
+    .optional();
+export const socialLinksSchema = z
+    .object({
+    facebook: urlSchema,
+    instagram: urlSchema,
+    twitter: urlSchema,
+    tiktok: urlSchema,
+    youtube: urlSchema,
+    website: urlSchema,
+})
+    .partial();
+export function requiredString(maxLength, fieldName) {
+    return z
+        .string()
+        .min(1, `${fieldName} is required`)
+        .max(maxLength, VALIDATION_MESSAGES.tooLong(fieldName, maxLength))
+        .trim();
+}
+export function optionalString(maxLength, fieldName) {
+    return z
+        .string()
+        .max(maxLength, VALIDATION_MESSAGES.tooLong(fieldName, maxLength))
+        .trim()
+        .optional()
+        .or(z.literal(''));
+}
+export function numberRange(min, max, fieldName) {
+    return z
+        .number()
+        .min(min, VALIDATION_MESSAGES.tooSmall(fieldName, min))
+        .max(max, VALIDATION_MESSAGES.tooLarge(fieldName, max));
+}
+export function stringToNumber() {
+    return z
+        .union([z.string(), z.number()])
+        .transform(v => (typeof v === 'string' ? parseFloat(v) : v))
+        .refine(v => !isNaN(v), VALIDATION_MESSAGES.INVALID_FORMAT);
+}
+export function stringToInt() {
+    return z
+        .union([z.string(), z.number()])
+        .refine(v => {
+        if (typeof v === 'string') {
+            return /^-?\d+$/.test(v.trim());
+        }
+        return Number.isInteger(v);
+    }, VALIDATION_MESSAGES.MUST_BE_INTEGER)
+        .transform(v => (typeof v === 'string' ? parseInt(v, 10) : v));
+}