nope-validator/lib/esm/NopeString.js

Fast and simple JS validator

import { urlRegex, emailRegex } from './consts.js';
import { NopePrimitive } from './NopePrimitive.js';
import { isNil } from './utils.js';

class NopeString extends NopePrimitive {
    constructor() {
        super(...arguments);
        this._type = 'string';
    }
    validate(entry, context) {
        const value = !!entry ? String(entry) : entry;
        return super.validate(value, context);
    }
    validateAsync(entry, context) {
        const value = !!entry ? String(entry) : entry;
        return super.validateAsync(value, context);
    }
    isEmpty(value) {
        return isNil(value) || value.trim().length === 0;
    }
    regex(regex, message = "Doesn't satisfy the rule") {
        const rule = (entry) => {
            if (this.isEmpty(entry)) {
                return;
            }
            if (!regex.test(entry)) {
                return message;
            }
        };
        return this.test(rule);
    }
    url(message = 'Input is not a valid url') {
        this.regex(urlRegex, message);
        return this;
    }
    email(message = 'Input is not a valid email') {
        this.regex(emailRegex, message);
        return this;
    }
    min(length, message) {
        this.greaterThan(length, message);
        return this;
    }
    max(length, message) {
        this.lessThan(length, message);
        return this;
    }
    greaterThan(length, message = 'Input is too short') {
        const rule = (entry) => {
            if (this.isEmpty(entry)) {
                return;
            }
            const value = entry;
            if (value.length <= length) {
                return message;
            }
        };
        return this.test(rule);
    }
    lessThan(length, message = 'Input is too long') {
        const rule = (entry) => {
            if (this.isEmpty(entry)) {
                return;
            }
            const value = entry;
            if (value.length >= length) {
                return message;
            }
        };
        return this.test(rule);
    }
    atLeast(length, message = 'Input is too short') {
        const rule = (entry) => {
            if (this.isEmpty(entry)) {
                return;
            }
            const value = entry;
            if (value.length < length) {
                return message;
            }
        };
        return this.test(rule);
    }
    atMost(length, message = 'Input is too long') {
        const rule = (entry) => {
            if (this.isEmpty(entry)) {
                return;
            }
            const value = entry;
            if (value.length > length) {
                return message;
            }
        };
        return this.test(rule);
    }
    between(startLength, endLength, atLeastMessage = 'Input is too short', atMostMessage = 'Input is too long') {
        if (startLength && endLength && startLength > endLength) {
            const rule = () => {
                throw Error('between must receive an initial length (startLength) smaller than the final length (endLength) parameter');
            };
            return this.test(rule);
        }
        this.atLeast(startLength, atLeastMessage);
        this.atMost(endLength, atMostMessage);
        return this;
    }
    exactLength(length, message = `Must be at exactly of length ${length}`) {
        const rule = (entry) => {
            if (this.isEmpty(entry)) {
                return;
            }
            const value = entry;
            if (value.length !== length) {
                return message;
            }
        };
        return this.test(rule);
    }
    trim() {
        const rule = (entry) => {
            this._entry = entry.trim();
            return;
        };
        return this.test(rule);
    }
}

export { NopeString };
//# sourceMappingURL=NopeString.js.map