nope-validator/lib/esm/NopeNumber.js

Fast and simple JS validator

import { NopePrimitive } from './NopePrimitive.js';

class NopeNumber extends NopePrimitive {
    constructor(message = 'The field is not a valid number') {
        super();
        this.message = 'The field is not a number';
        this._type = 'number';
        this.message = message;
    }
    integer(message = 'Input must be an integer') {
        const rule = (entry) => {
            if (this.isEmpty(entry)) {
                return;
            }
            if (entry !== Math.floor(entry)) {
                return message;
            }
        };
        return this.test(rule);
    }
    min(size, message) {
        this.greaterThan(size, message);
        return this;
    }
    max(size, message) {
        this.lessThan(size, message);
        return this;
    }
    greaterThan(size, message = 'Input is too small') {
        const rule = (entry) => {
            if (this.isEmpty(entry)) {
                return;
            }
            if (entry <= size) {
                return message;
            }
        };
        return this.test(rule);
    }
    lessThan(size, message = 'Input is too large') {
        const rule = (entry) => {
            if (this.isEmpty(entry)) {
                return;
            }
            if (entry >= size) {
                return message;
            }
        };
        return this.test(rule);
    }
    atLeast(size, message = 'Input is too small') {
        const rule = (entry) => {
            if (this.isEmpty(entry)) {
                return;
            }
            if (entry < size) {
                return message;
            }
        };
        return this.test(rule);
    }
    atMost(size, message = 'Input is too large') {
        const rule = (entry) => {
            if (this.isEmpty(entry)) {
                return;
            }
            if (entry > size) {
                return message;
            }
        };
        return this.test(rule);
    }
    between(sizeStart, sizeEnd, atLeastMessage = 'Input is too small', atMostMessage = 'Input is too large') {
        if (sizeStart && sizeEnd && sizeStart > sizeEnd) {
            const rule = () => {
                throw Error('between must receive an initial size (sizeStart) smaller than the final size (sizeEnd) parameter');
            };
            return this.test(rule);
        }
        this.atLeast(sizeStart, atLeastMessage);
        this.atMost(sizeEnd, atMostMessage);
        return this;
    }
    positive(message = 'Input must be positive') {
        this.greaterThan(0, message);
        return this;
    }
    negative(message = 'Input must be negative') {
        this.lessThan(0, message);
        return this;
    }
    validate(entry, context) {
        const value = !!entry ? Number(entry) : entry;
        if (!this.isEmpty(value) && Number.isNaN(value)) {
            return this.message;
        }
        return super.validate(value, context);
    }
    validateAsync(entry, context) {
        const value = !!entry ? Number(entry) : entry;
        if (!this.isEmpty(value) && Number.isNaN(value)) {
            return Promise.resolve(this.message);
        }
        return super.validateAsync(value, context);
    }
}

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