@bshg/validation/lib/validators/validators-fn/numbers.js

Validation Library for TypeScript projects

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Numbers = void 0;
const base_1 = require("./base");
const messages_1 = require("../messages");
const msgs = () => messages_1.CurrentLocalize.number;
class Numbers extends base_1.TypeValidator {
    undefined() {
        return new Numbers();
    }
    required(options) {
        return this.useCostume({
            error: value => value === undefined,
            message: msgs().required,
            options,
        });
    }
    min(minValue, options) {
        return this.useCostume({
            error: value => value !== undefined && value < minValue,
            message: msgs().min,
            options: options,
            args: [minValue],
        });
    }
    max(maxValue, options) {
        return this.useCostume({
            error: value => value !== undefined && value > maxValue,
            message: msgs().max,
            options: options,
            args: [maxValue],
        });
    }
    range(minValue, maxValue, options) {
        return this.useCostume({
            error: value => value !== undefined && (value < minValue || value > maxValue),
            message: msgs().range,
            options: options,
            args: [minValue, maxValue],
        });
    }
    integer(options) {
        return this.useCostume({
            error: value => value !== undefined && !Number.isInteger(value),
            message: msgs().integer,
            options: options,
        });
    }
    positive(options) {
        return this.min(0, { ...options, message: (options === null || options === void 0 ? void 0 : options.message) || msgs().positive });
    }
    negative(options) {
        return this.max(0, { ...options, message: (options === null || options === void 0 ? void 0 : options.message) || msgs().negative });
    }
    decimal(options) {
        return this.useCostume({
            error: value => value !== undefined && Number.isInteger(value),
            message: msgs().decimal,
            options: options,
        });
    }
    multipleOf(divisor, options) {
        return this.useCostume({
            error: value => value !== undefined && value % divisor !== 0,
            message: msgs().multipleOf,
            options: options,
            args: [divisor],
        });
    }
    betweenExclusive(minValue, maxValue, options) {
        return this.useCostume({
            error: value => value !== undefined && (value <= minValue || value >= maxValue),
            message: msgs().betweenExclusive,
            options: options,
            args: [minValue, maxValue],
        });
    }
    even(options) {
        return this.useCostume({
            error: value => value !== undefined && value % 2 !== 0,
            message: msgs().even,
            options: options,
        });
    }
    odd(options) {
        return this.useCostume({
            error: value => value !== undefined && value % 2 === 0,
            message: msgs().odd,
            options: options,
        });
    }
    positiveInteger(options) {
        return this.useCostume({
            error: value => value !== undefined && (!Number.isInteger(value) || value <= 0),
            message: msgs().positiveInteger,
            options: options,
        });
    }
    negativeInteger(options) {
        return this.useCostume({
            error: value => value !== undefined && (!Number.isInteger(value) || value >= 0),
            message: msgs().negativeInteger,
            options: options,
        });
    }
    positiveDecimal(options) {
        return this.useCostume({
            error: value => value !== undefined && (Number.isInteger(value) || value <= 0),
            message: msgs().positiveDecimal,
            options: options,
        });
    }
    negativeDecimal(options) {
        return this.useCostume({
            error: value => value !== undefined && (Number.isInteger(value) || value >= 0),
            message: msgs().negativeDecimal,
            options: options,
        });
    }
    divisibleBy(divisor, options) {
        return this.useCostume({
            error: value => value !== undefined && !Number.isInteger(value / divisor),
            message: msgs().divisibleBy,
            options: options,
            args: [divisor],
        });
    }
    perfectSquare(options) {
        return this.useCostume({
            error: value => value !== undefined && !Number.isInteger(Math.sqrt(value)),
            message: msgs().perfectSquare,
            options: options,
        });
    }
    primeNumber(options) {
        return this.useCostume({
            error: value => {
                if (value === undefined || value < 2)
                    return true;
                for (let i = 2; i <= Math.sqrt(value); i++) {
                    if (value % i === 0)
                        return true;
                }
                return false;
            },
            message: msgs().primeNumber,
            options: options,
        });
    }
    fibonacciNumber(options) {
        return this.useCostume({
            error: value => {
                if (value === undefined || value < 0)
                    return true;
                let a = 0, b = 1;
                while (b < value) {
                    let temp = b;
                    b += a;
                    a = temp;
                }
                return b !== value;
            },
            message: msgs().fibonacciNumber,
            options: options,
        });
    }
    powerOfTwo(options) {
        return this.useCostume({
            error: value => value !== undefined && (value & (value - 1)) !== 0,
            message: msgs().powerOfTwo,
            options: options,
        });
    }
    ////////////////////////////////////////////
    as(key, options) {
        return this.useCostume({
            error: (value, parent) => value != parent[key],
            message: msgs().as,
            options: options,
            args: [key],
        });
    }
}
exports.Numbers = Numbers;