hvp-shared 2.0.0

package/dist/validation/__tests__/address.validation.test.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const address_validation_1 = require("../address.validation");
+describe('validateAddress', () => {
+    const validAddress = {
+        street: 'Calle 10',
+        exteriorNumber: '123',
+        interiorNumber: 'A',
+        neighborhood: 'Centro',
+        city: 'Mérida',
+        state: 'YUC',
+        postalCode: '97000',
+        country: 'México'
+    };
+    describe('valid addresses', () => {
+        it('should accept valid complete address', () => {
+            const result = (0, address_validation_1.validateAddress)(validAddress);
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept address without interior number', () => {
+            const { interiorNumber, ...addressWithoutInterior } = validAddress;
+            const result = (0, address_validation_1.validateAddress)(addressWithoutInterior);
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept country "Mexico" without accent', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, country: 'Mexico' });
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept country in uppercase', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, country: 'MÉXICO' });
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept address with whitespace (trimmed)', () => {
+            const result = (0, address_validation_1.validateAddress)({
+                ...validAddress,
+                street: '  Calle 10  ',
+                city: '  Mérida  '
+            });
+            expect(result.isValid).toBe(true);
+        });
+    });
+    describe('required fields', () => {
+        it('should reject missing street', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, street: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Calle es requerida');
+        });
+        it('should reject missing exterior number', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, exteriorNumber: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Número exterior es requerido');
+        });
+        it('should reject missing neighborhood', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, neighborhood: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Colonia es requerida');
+        });
+        it('should reject missing city', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, city: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Ciudad es requerida');
+        });
+        it('should reject missing postal code', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, postalCode: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Código postal es requerido');
+        });
+        it('should reject missing state', () => {
+            const { state, ...addressWithoutState } = validAddress;
+            const result = (0, address_validation_1.validateAddress)(addressWithoutState);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Estado es requerido');
+        });
+        it('should reject missing country', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, country: '' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('País es requerido');
+        });
+    });
+    describe('postal code validation', () => {
+        it('should reject postal code with less than 5 digits', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, postalCode: '9700' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('5 dígitos');
+        });
+        it('should reject postal code with more than 5 digits', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, postalCode: '970001' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('5 dígitos');
+        });
+        it('should reject postal code with letters', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, postalCode: '9700A' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('5 dígitos');
+        });
+    });
+    describe('state code validation', () => {
+        it('should accept all valid Mexican state codes', () => {
+            const validStates = [
+                'AGS', 'BC', 'BCS', 'CAMP', 'CHIS', 'CHIH', 'COAH', 'COL', 'CDMX',
+                'DGO', 'GTO', 'GRO', 'HGO', 'JAL', 'MEX', 'MICH', 'MOR', 'NAY',
+                'NL', 'OAX', 'PUE', 'QRO', 'QROO', 'SLP', 'SIN', 'SON', 'TAB',
+                'TAMPS', 'TLAX', 'VER', 'YUC', 'ZAC'
+            ];
+            validStates.forEach(state => {
+                const result = (0, address_validation_1.validateAddress)({ ...validAddress, state: state });
+                expect(result.isValid).toBe(true);
+            });
+        });
+        it('should reject invalid state code', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, state: 'INVALID' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Código de estado inválido');
+        });
+    });
+    describe('country validation', () => {
+        it('should reject non-Mexican country', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, country: 'USA' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('México');
+        });
+        it('should reject other countries', () => {
+            const result = (0, address_validation_1.validateAddress)({ ...validAddress, country: 'Canada' });
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('México');
+        });
+    });
+});
+describe('POSTAL_CODE_PATTERN', () => {
+    it('should match valid 5-digit postal code', () => {
+        expect(address_validation_1.POSTAL_CODE_PATTERN.test('97000')).toBe(true);
+    });
+    it('should match postal code starting with 0', () => {
+        expect(address_validation_1.POSTAL_CODE_PATTERN.test('01000')).toBe(true);
+    });
+    it('should not match 4-digit code', () => {
+        expect(address_validation_1.POSTAL_CODE_PATTERN.test('9700')).toBe(false);
+    });
+    it('should not match 6-digit code', () => {
+        expect(address_validation_1.POSTAL_CODE_PATTERN.test('970001')).toBe(false);
+    });
+});

package/dist/validation/__tests__/email.validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validation/__tests__/email.validation.test.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const email_validation_1 = require("../email.validation");
+describe('validateEmail', () => {
+    describe('valid emails', () => {
+        it('should accept valid email', () => {
+            const result = (0, email_validation_1.validateEmail)('test@example.com');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept email with subdomain', () => {
+            const result = (0, email_validation_1.validateEmail)('test@mail.example.com');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept email with numbers', () => {
+            const result = (0, email_validation_1.validateEmail)('test123@example.com');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept email with dots in local part', () => {
+            const result = (0, email_validation_1.validateEmail)('test.user@example.com');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept email with plus sign', () => {
+            const result = (0, email_validation_1.validateEmail)('test+tag@example.com');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept uppercase email (normalized)', () => {
+            const result = (0, email_validation_1.validateEmail)('TEST@EXAMPLE.COM');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept email with whitespace (trimmed)', () => {
+            const result = (0, email_validation_1.validateEmail)('  test@example.com  ');
+            expect(result.isValid).toBe(true);
+        });
+    });
+    describe('invalid emails', () => {
+        it('should reject empty string', () => {
+            const result = (0, email_validation_1.validateEmail)('');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email es requerido');
+        });
+        it('should reject null', () => {
+            const result = (0, email_validation_1.validateEmail)(null);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email es requerido');
+        });
+        it('should reject undefined', () => {
+            const result = (0, email_validation_1.validateEmail)(undefined);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email es requerido');
+        });
+        it('should reject whitespace only', () => {
+            const result = (0, email_validation_1.validateEmail)('   ');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email es requerido');
+        });
+        it('should reject email without @', () => {
+            const result = (0, email_validation_1.validateEmail)('testexample.com');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email inválido');
+        });
+        it('should reject email without domain', () => {
+            const result = (0, email_validation_1.validateEmail)('test@');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email inválido');
+        });
+        it('should reject email without local part', () => {
+            const result = (0, email_validation_1.validateEmail)('@example.com');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email inválido');
+        });
+        it('should reject email without TLD', () => {
+            const result = (0, email_validation_1.validateEmail)('test@example');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email inválido');
+        });
+        it('should reject email with spaces', () => {
+            const result = (0, email_validation_1.validateEmail)('test @example.com');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('Email inválido');
+        });
+    });
+});
+describe('normalizeEmail', () => {
+    it('should convert to lowercase', () => {
+        expect((0, email_validation_1.normalizeEmail)('TEST@EXAMPLE.COM')).toBe('test@example.com');
+    });
+    it('should trim whitespace', () => {
+        expect((0, email_validation_1.normalizeEmail)('  test@example.com  ')).toBe('test@example.com');
+    });
+    it('should handle mixed case', () => {
+        expect((0, email_validation_1.normalizeEmail)('Test@Example.Com')).toBe('test@example.com');
+    });
+});
+describe('EMAIL_PATTERN', () => {
+    it('should match valid email', () => {
+        expect(email_validation_1.EMAIL_PATTERN.test('test@example.com')).toBe(true);
+    });
+    it('should not match invalid email', () => {
+        expect(email_validation_1.EMAIL_PATTERN.test('invalid')).toBe(false);
+    });
+});

package/dist/validation/__tests__/phone.validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validation/__tests__/phone.validation.test.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const phone_validation_1 = require("../phone.validation");
+describe('validatePhone', () => {
+    describe('valid phones', () => {
+        it('should accept valid 10-digit phone', () => {
+            const result = (0, phone_validation_1.validatePhone)('9991234567');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept phone with whitespace (trimmed)', () => {
+            const result = (0, phone_validation_1.validatePhone)('  9991234567  ');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept undefined (phone is optional)', () => {
+            const result = (0, phone_validation_1.validatePhone)(undefined);
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept null (phone is optional)', () => {
+            const result = (0, phone_validation_1.validatePhone)(null);
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept empty string (phone is optional)', () => {
+            const result = (0, phone_validation_1.validatePhone)('');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept whitespace only (phone is optional)', () => {
+            const result = (0, phone_validation_1.validatePhone)('   ');
+            expect(result.isValid).toBe(true);
+        });
+    });
+    describe('invalid phones', () => {
+        it('should reject phone with less than 10 digits', () => {
+            const result = (0, phone_validation_1.validatePhone)('999123456');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+        it('should reject phone with more than 10 digits', () => {
+            const result = (0, phone_validation_1.validatePhone)('99912345678');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+        it('should reject phone with letters', () => {
+            const result = (0, phone_validation_1.validatePhone)('999123456a');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+        it('should reject phone with special characters', () => {
+            const result = (0, phone_validation_1.validatePhone)('999-123-4567');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+        it('should reject phone with spaces inside', () => {
+            const result = (0, phone_validation_1.validatePhone)('999 123 4567');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+        it('should reject phone with parentheses', () => {
+            const result = (0, phone_validation_1.validatePhone)('(999)1234567');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('10 dígitos');
+        });
+    });
+});
+describe('PHONE_PATTERN', () => {
+    it('should match valid 10-digit phone', () => {
+        expect(phone_validation_1.PHONE_PATTERN.test('9991234567')).toBe(true);
+    });
+    it('should not match invalid phone', () => {
+        expect(phone_validation_1.PHONE_PATTERN.test('999-123-4567')).toBe(false);
+    });
+    it('should not match phone with less than 10 digits', () => {
+        expect(phone_validation_1.PHONE_PATTERN.test('999123456')).toBe(false);
+    });
+});

package/dist/validation/__tests__/rfc.validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validation/__tests__/rfc.validation.test.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rfc_validation_1 = require("../rfc.validation");
+describe('validateRFC', () => {
+    describe('valid RFCs', () => {
+        it('should accept valid RFC persona moral (12 chars)', () => {
+            const result = (0, rfc_validation_1.validateRFC)('HVP850101AB1');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept valid RFC persona física (13 chars)', () => {
+            const result = (0, rfc_validation_1.validateRFC)('GARC850101AB1');
+            expect(result.isValid).toBe(true);
+            expect(result.error).toBeUndefined();
+        });
+        it('should accept RFC with Ñ', () => {
+            const result = (0, rfc_validation_1.validateRFC)('MÑO850101AB1');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept RFC with &', () => {
+            const result = (0, rfc_validation_1.validateRFC)('M&O850101AB1');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept lowercase RFC (normalized)', () => {
+            const result = (0, rfc_validation_1.validateRFC)('hvp850101ab1');
+            expect(result.isValid).toBe(true);
+        });
+        it('should accept RFC with whitespace (trimmed)', () => {
+            const result = (0, rfc_validation_1.validateRFC)('  HVP850101AB1  ');
+            expect(result.isValid).toBe(true);
+        });
+    });
+    describe('invalid RFCs', () => {
+        it('should reject empty string', () => {
+            const result = (0, rfc_validation_1.validateRFC)('');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('RFC es requerido');
+        });
+        it('should reject null', () => {
+            const result = (0, rfc_validation_1.validateRFC)(null);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('RFC es requerido');
+        });
+        it('should reject undefined', () => {
+            const result = (0, rfc_validation_1.validateRFC)(undefined);
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('RFC es requerido');
+        });
+        it('should reject whitespace only', () => {
+            const result = (0, rfc_validation_1.validateRFC)('   ');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toBe('RFC es requerido');
+        });
+        it('should reject RFC too short', () => {
+            const result = (0, rfc_validation_1.validateRFC)('HVP850101');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('RFC inválido');
+        });
+        it('should reject RFC too long', () => {
+            const result = (0, rfc_validation_1.validateRFC)('GARC850101AB1X');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('RFC inválido');
+        });
+        it('should reject RFC with invalid characters', () => {
+            const result = (0, rfc_validation_1.validateRFC)('HVP-850101AB1');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('RFC inválido');
+        });
+        it('should reject RFC with wrong format', () => {
+            const result = (0, rfc_validation_1.validateRFC)('123456789012');
+            expect(result.isValid).toBe(false);
+            expect(result.error).toContain('RFC inválido');
+        });
+    });
+});
+describe('normalizeRFC', () => {
+    it('should convert to uppercase', () => {
+        expect((0, rfc_validation_1.normalizeRFC)('hvp850101ab1')).toBe('HVP850101AB1');
+    });
+    it('should trim whitespace', () => {
+        expect((0, rfc_validation_1.normalizeRFC)('  HVP850101AB1  ')).toBe('HVP850101AB1');
+    });
+    it('should handle mixed case', () => {
+        expect((0, rfc_validation_1.normalizeRFC)('HvP850101Ab1')).toBe('HVP850101AB1');
+    });
+});
+describe('RFC_PATTERN', () => {
+    it('should match valid RFC persona moral', () => {
+        expect(rfc_validation_1.RFC_PATTERN.test('HVP850101AB1')).toBe(true);
+    });
+    it('should match valid RFC persona física', () => {
+        expect(rfc_validation_1.RFC_PATTERN.test('GARC850101AB1')).toBe(true);
+    });
+    it('should not match invalid RFC', () => {
+        expect(rfc_validation_1.RFC_PATTERN.test('INVALID')).toBe(false);
+    });
+});

package/dist/validation/address.validation.d.ts

@@ -0,0 +1,27 @@
+import { ValidationResult } from './rfc.validation';
+import { MexicanStateCode } from '../constants/mexican-states';
+/**
+ * Props for address validation
+ */
+export interface AddressValidationProps {
+    street: string;
+    exteriorNumber: string;
+    interiorNumber?: string;
+    neighborhood: string;
+    city: string;
+    state: MexicanStateCode;
+    zipCode: string;
+    country: string;
+}
+/**
+ * Validates address fields
+ *
+ * @param props - Address properties to validate
+ * @returns ValidationResult with isValid flag and optional error message
+ */
+export declare function validateAddress(props: Partial<AddressValidationProps>): ValidationResult;
+/**
+ * Regex pattern for postal code validation (5 digits)
+ * Can be used directly in form libraries that accept regex
+ */
+export declare const POSTAL_CODE_PATTERN: RegExp;

package/dist/validation/address.validation.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POSTAL_CODE_PATTERN = void 0;
+exports.validateAddress = validateAddress;
+const mexican_states_1 = require("../constants/mexican-states");
+/**
+ * Validates address fields
+ *
+ * @param props - Address properties to validate
+ * @returns ValidationResult with isValid flag and optional error message
+ */
+function validateAddress(props) {
+    if (!props.street?.trim()) {
+        return { isValid: false, error: 'Calle es requerida' };
+    }
+    if (!props.exteriorNumber?.trim()) {
+        return { isValid: false, error: 'Número exterior es requerido' };
+    }
+    if (!props.neighborhood?.trim()) {
+        return { isValid: false, error: 'Colonia es requerida' };
+    }
+    if (!props.city?.trim()) {
+        return { isValid: false, error: 'Ciudad es requerida' };
+    }
+    if (!props.zipCode?.trim()) {
+        return { isValid: false, error: 'Código postal es requerido' };
+    }
+    if (!/^\d{5}$/.test(props.zipCode.trim())) {
+        return { isValid: false, error: 'Código postal inválido. Debe tener 5 dígitos' };
+    }
+    if (!props.state) {
+        return { isValid: false, error: 'Estado es requerido' };
+    }
+    // Check if state is valid
+    if (!(props.state in mexican_states_1.MEXICAN_STATES)) {
+        return { isValid: false, error: 'Código de estado inválido' };
+    }
+    if (!props.country?.trim()) {
+        return { isValid: false, error: 'País es requerido' };
+    }
+    const normalizedCountry = props.country.toLowerCase().trim();
+    if (normalizedCountry !== 'méxico' && normalizedCountry !== 'mexico') {
+        return { isValid: false, error: 'Solo se soporta México como país' };
+    }
+    return { isValid: true };
+}
+/**
+ * Regex pattern for postal code validation (5 digits)
+ * Can be used directly in form libraries that accept regex
+ */
+exports.POSTAL_CODE_PATTERN = /^\d{5}$/;

package/dist/validation/email.validation.d.ts

@@ -0,0 +1,20 @@
+import { ValidationResult } from './rfc.validation';
+/**
+ * Validates email format
+ *
+ * @param value - Email to validate
+ * @returns ValidationResult with isValid flag and optional error message
+ */
+export declare function validateEmail(value: string | null | undefined): ValidationResult;
+/**
+ * Normalizes email to lowercase and trimmed
+ *
+ * @param value - Email to normalize
+ * @returns Normalized email
+ */
+export declare function normalizeEmail(value: string): string;
+/**
+ * Regex pattern for email validation
+ * Can be used directly in form libraries that accept regex
+ */
+export declare const EMAIL_PATTERN: RegExp;

package/dist/validation/email.validation.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EMAIL_PATTERN = void 0;
+exports.validateEmail = validateEmail;
+exports.normalizeEmail = normalizeEmail;
+/**
+ * Validates email format
+ *
+ * @param value - Email to validate
+ * @returns ValidationResult with isValid flag and optional error message
+ */
+function validateEmail(value) {
+    if (!value || !value.trim()) {
+        return { isValid: false, error: 'Email es requerido' };
+    }
+    const normalized = value.toLowerCase().trim();
+    // Basic email pattern
+    const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailPattern.test(normalized)) {
+        return { isValid: false, error: 'Email inválido' };
+    }
+    return { isValid: true };
+}
+/**
+ * Normalizes email to lowercase and trimmed
+ *
+ * @param value - Email to normalize
+ * @returns Normalized email
+ */
+function normalizeEmail(value) {
+    return value.toLowerCase().trim();
+}
+/**
+ * Regex pattern for email validation
+ * Can be used directly in form libraries that accept regex
+ */
+exports.EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

package/dist/validation/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Validation Functions
+ * Pure, stateless validation logic shared between frontend and backend
+ */
+export * from './rfc.validation';
+export * from './email.validation';
+export * from './phone.validation';
+export * from './address.validation';

package/dist/validation/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Validation Functions
+ * Pure, stateless validation logic shared between frontend and backend
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rfc.validation"), exports);
+__exportStar(require("./email.validation"), exports);
+__exportStar(require("./phone.validation"), exports);
+__exportStar(require("./address.validation"), exports);

package/dist/validation/phone.validation.d.ts

@@ -0,0 +1,14 @@
+import { ValidationResult } from './rfc.validation';
+/**
+ * Validates Mexican phone number format
+ * Phone is optional - undefined/null/empty string are valid
+ *
+ * @param value - Phone to validate
+ * @returns ValidationResult with isValid flag and optional error message
+ */
+export declare function validatePhone(value: string | null | undefined): ValidationResult;
+/**
+ * Regex pattern for phone validation (10 digits)
+ * Can be used directly in form libraries that accept regex
+ */
+export declare const PHONE_PATTERN: RegExp;

package/dist/validation/phone.validation.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHONE_PATTERN = void 0;
+exports.validatePhone = validatePhone;
+/**
+ * Validates Mexican phone number format
+ * Phone is optional - undefined/null/empty string are valid
+ *
+ * @param value - Phone to validate
+ * @returns ValidationResult with isValid flag and optional error message
+ */
+function validatePhone(value) {
+    // Phone is optional, undefined/null is valid
+    if (value === undefined || value === null) {
+        return { isValid: true };
+    }
+    const trimmed = value.trim();
+    // Empty string is also valid (optional field)
+    if (trimmed === '') {
+        return { isValid: true };
+    }
+    // Mexican phone: 10 digits
+    const phonePattern = /^\d{10}$/;
+    if (!phonePattern.test(trimmed)) {
+        return { isValid: false, error: 'Teléfono inválido. Debe tener 10 dígitos' };
+    }
+    return { isValid: true };
+}
+/**
+ * Regex pattern for phone validation (10 digits)
+ * Can be used directly in form libraries that accept regex
+ */
+exports.PHONE_PATTERN = /^\d{10}$/;