jet-validators/dist/cjs/complex/isInRange.js

Fast, zero-dependency TypeScript validators and utilities for runtime checks, parsing, and lightweight object schema validation.

import { markSafe } from '../utils/parseObject/mark-safe.js';
export function isInRange(min, max) {
    return isInRangeHelper(false, false, false, min, max);
}
export function isOptionalInRange(min, max) {
    return isInRangeHelper(true, false, false, min, max);
}
export function isNullableInRange(min, max) {
    return isInRangeHelper(false, true, false, min, max);
}
export function isNullishInRange(min, max) {
    return isInRangeHelper(true, true, false, min, max);
}
export function isInRangeArray(min, max) {
    return isInRangeHelper(false, false, true, min, max);
}
export function isOptionalInRangeArray(min, max) {
    return isInRangeHelper(true, false, true, min, max);
}
export function isNullableInRangeArray(min, max) {
    return isInRangeHelper(false, true, true, min, max);
}
export function isNullishInRangeArray(min, max) {
    return isInRangeHelper(true, true, true, min, max);
}
function isInRangeHelper(optional, nullable, isArr, min, max) {
    const rangeFn = setupIsInRangeInternalFn(min, max);
    const validator = (arg) => {
        if (arg === undefined) {
            return optional;
        }
        if (arg === null) {
            return nullable;
        }
        if (isArr) {
            if (!Array.isArray(arg)) {
                return false;
            }
            for (let i = 0; i < arg.length; i += 1) {
                if (!isInRangeCheckType(arg[i], rangeFn)) {
                    return false;
                }
            }
            return true;
        }
        return isInRangeCheckType(arg, rangeFn);
    };
    return markSafe(validator);
}
function isInRangeCheckType(arg, rangeFn) {
    if (typeof arg === 'number') {
        return rangeFn(arg);
    }
    if (typeof arg === 'string') {
        const casted = Number(arg);
        if (Number.isNaN(casted)) {
            return false;
        }
        return rangeFn(casted);
    }
    return false;
}
function setupIsInRangeInternalFn(min, max) {
    const minBound = parseRangeBound(min);
    const maxBound = parseRangeBound(max);
    return (arg) => {
        if (minBound) {
            if (minBound.inclusive) {
                if (arg < minBound.value) {
                    return false;
                }
            }
            else if (arg <= minBound.value) {
                return false;
            }
        }
        if (maxBound) {
            if (maxBound.inclusive) {
                if (arg > maxBound.value) {
                    return false;
                }
            }
            else if (arg >= maxBound.value) {
                return false;
            }
        }
        return true;
    };
}
function parseRangeBound(param) {
    if (Array.isArray(param)) {
        if (param.length === 0) {
            return null;
        }
        if (param.length === 1) {
            return {
                value: param[0],
                inclusive: true,
            };
        }
    }
    else {
        return {
            value: param,
            inclusive: false,
        };
    }
    throw new Error('min and max must be number, [number], or []');
}