@gdimx/validateform/src/index.ts

Libreria de validaciones para campos

// Valida si el campo no está vacío
export function required(value: string | boolean): boolean{
    // Si el valor es booleano, lo tratamos como falso
    if(typeof value === 'boolean'){
        return false;
    }

    // Convierte caulquier tipo de cadena y luego valida
    return String(value).trim() !== '';
}

// Valida si el campo tiene al menos una longitud mínima
export function minLengthValid(value: string, minLength: number): boolean{
    return value.length >= minLength;
}

// Valida si el campo tiene una longitud Máxima
export function maxLengthValid(value: string, maxLength: number): boolean{
    return value.length <= maxLength;
}

// Valida si el campo es un correo electrónico válido
export function email(value: string): boolean{
    const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
    return regex.test(value);
}

// Valida si el campo es un número
export function isNumber(value: string): boolean{
    const regex = /^[0-9]+$/;
    return regex.test(value);
}

// Valida si el campo tiene solo caracteres permitidos
export function allowedCharacters(value: string, allowedChars: string): boolean{
    const escapedChars = allowedChars.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
    const regex = new RegExp(`^[${escapedChars}]+$`);
    return regex.test(value);
}

// Valida si el campo tiene caracteres prohibidos
export function disallowedCharacters(value: string, disallowedChars: string): boolean{
    const escapedChars = disallowedChars.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
    const regex = new RegExp(`[^${escapedChars}]*$`);
    return regex.test(value);
}

// Valida si el campo es un teléfono válido
export function phone(value: string): boolean{
    const regex = /^[+]*[(]{0,1}[0-9]{1,4}[)]{0,1}[-\s/0-9]*$/;
    return regex.test(value);
}

// Valida si el campo es una fecha válida (formato YYYY-MM-DD)
export function date(value: string): boolean {
    const regex = /^\d{4}-\d{2}-\d{2}$/;
    if(!regex.test(value)) return false;
    const dateObject = new Date(value);
    // Compara la fecha con el formato original
    return dateObject.toISOString().slice(0,10) === value;
}

// Valida si el campo tiene solo mayúsculas
export function isCapitalLetter(value: string): boolean{
    return /^[A-Z]+$/.test(value);
}

// Valida si el campo tiene solo mínusculas
export function isLowerCase(value: string){
    return /^[a-z]+$/.test(value);
}

// Valida si el campo permite ambos, mayuscula y minuscula
export function isBoth(value: string){
    return /^[a-zA-Z]+$/.test(value);
}

// Valida si el campo tiene saltos de línea
export function allowsSpaces(value: string): boolean{
    return /\s/.test(value);
}

// Valida si el campo tiene saltos de línea
export function allowLineBreaks(value: string): boolean{
    return /\n/.test(value);
}

// Validación alphanumeric
export function alphaNumeric(value: string): boolean{
    return /^[a-zA-Z0-9]+$/.test(value);
}

// Validación Alpha
export function alpha(value: string): boolean {
    return /^[a-zA-Z]+$/.test(value);
}

// Validación decimal
export function decimal(value: string): boolean {
    return /^\d+(\.\d+)?$/.test(value);
}


// Método para aplicar validaciones multiples en el DOM
export function applyValidationOnEvent(control: HTMLElement, eventType: string): void {
    control.addEventListener(eventType, (event: Event) => {
        const target = event.target as HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
        const validationAttr = target.getAttribute('validation-type');
        const minLength = parseInt(target.getAttribute('data-min-length') || '0', 10);
        const maxLength = parseInt(target.getAttribute('data-max-length') || '0', 10);
        const allowedChars = target.getAttribute('data-allowed-chars') || '';
        const disallowedChars = target.getAttribute('data-disallowed-chars') || '';

        if (validationAttr) {
            const validations = validationAttr.split(',').map(v => v.trim());
            let valid = true;

            for (const type of validations) {
                let currentValid = true;

                switch (type) {
                    case 'required':
                        currentValid = required(target.value);
                        break;
                    case 'email':
                        currentValid = email(target.value);
                        break;
                    case 'minLength':
                        currentValid = minLengthValid(target.value, minLength);
                        break;
                    case 'maxLength':
                        currentValid = maxLengthValid(target.value, maxLength);
                        break;
                    case 'number':
                        currentValid = isNumber(target.value);
                        break;
                    case 'decimal':
                        currentValid = decimal(target.value);
                        break;
                    case 'phone':
                        currentValid = phone(target.value);
                        break;
                    case 'date':
                        currentValid = date(target.value);
                        break;
                    case 'capital':
                        currentValid = isCapitalLetter(target.value);
                        break;
                    case 'lower':
                        currentValid = isLowerCase(target.value);
                        break;
                    case 'both':
                        currentValid = isBoth(target.value);
                        break;
                    case 'alpha':
                        currentValid = alpha(target.value);
                        break;
                    case 'alphanumeric':
                        currentValid = alphaNumeric(target.value);
                        break;
                    case 'allowed':
                        currentValid = allowedCharacters(target.value, allowedChars);
                        break;
                    case 'disallowed':
                        currentValid = disallowedCharacters(target.value, disallowedChars);
                        break;
                    case 'space':
                        currentValid = !allowsSpaces(target.value);
                        break;
                    case 'newline':
                        currentValid = !allowLineBreaks(target.value);
                        break;
                    default:
                        currentValid = true;
                }

                if (!currentValid) {
                    valid = false;
                    break;
                }
            }

            if (!valid) {
                target.classList.add('invalid');
            } else {
                target.classList.remove('invalid');
            }
        }
    });
}