jet-validators/dist/cjs/utils/simple-utils.js

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

import { isFunction, isString } from '../basic.js';
const kTransformFunction = Symbol('transform-function');
const BOOLEAN_MAP = {
    true: true,
    false: false,
    yes: true,
    no: false,
    '1': true,
    '0': false,
};
export function nonNullable(cb) {
    return (arg) => {
        if (arg === null || arg === undefined) {
            return false;
        }
        else {
            return cb(arg);
        }
    };
}
export function makeOptional(cb) {
    return (arg) => {
        if (arg === undefined) {
            return true;
        }
        else {
            return cb(arg);
        }
    };
}
export function makeNullable(cb) {
    return (arg) => {
        if (arg === null) {
            return true;
        }
        else {
            return cb(arg);
        }
    };
}
export function makeNullish(cb) {
    return (arg) => {
        if (arg === null || arg === undefined) {
            return true;
        }
        else {
            return cb(arg);
        }
    };
}
export function transform(transformFn, validate) {
    const fn = (arg, cb) => {
        if (arg !== undefined) {
            arg = transformFn(arg);
        }
        const isValid = validate(arg);
        cb?.(arg, isValid);
        return isValid;
    };
    fn[kTransformFunction] = true;
    Object.defineProperty(fn, 'name', {
        value: `transform-${validate.name}`,
    });
    return fn;
}
export function isTransformFn(arg) {
    return (isFunction(arg) &&
        arg[kTransformFunction] === true);
}
export function parseBoolean(arg, errMsg) {
    if (typeof arg === 'boolean')
        return arg;
    if (typeof arg === 'number') {
        if (arg === 1)
            return true;
        if (arg === 0)
            return false;
    }
    if (typeof arg === 'string') {
        const normalized = arg.toLowerCase();
        if (normalized in BOOLEAN_MAP)
            return BOOLEAN_MAP[normalized];
    }
    throw new Error(errMsg ?? 'Argument must be a valid boolean.');
}
export function parseOptionalBoolean(arg) {
    if (arg === undefined) {
        return arg;
    }
    else {
        return parseBoolean(arg, 'Argument must be a valid boolean | undefined.');
    }
}
export function parseNullableBoolean(arg) {
    if (arg === null) {
        return arg;
    }
    else {
        return parseBoolean(arg, 'Argument must be a valid boolean | null.');
    }
}
export function parseNullishBoolean(arg) {
    if (arg === null || arg === undefined) {
        return arg;
    }
    else {
        return parseBoolean(arg, 'Argument must be a valid boolean | null | undefined.');
    }
}
export function parseJson(arg) {
    if (isString(arg)) {
        return JSON.parse(arg);
    }
    else {
        throw Error('JSON parse argument must be a string.');
    }
}
export function parseOptionalJson(arg) {
    if (arg === undefined) {
        return arg;
    }
    else if (isString(arg)) {
        return JSON.parse(arg);
    }
    else {
        throw Error('JSON parse argument must be string or undefined.');
    }
}
export function parseNullableJson(arg) {
    if (arg === null) {
        return arg;
    }
    else if (isString(arg)) {
        return JSON.parse(arg);
    }
    else {
        throw Error('JSON parse argument must be string or null.');
    }
}
export function parseNullishJson(arg) {
    if (arg === null || arg === undefined) {
        return arg;
    }
    else if (isString(arg)) {
        return JSON.parse(arg);
    }
    else {
        throw Error('JSON parse argument must be string, null, or undefined.');
    }
}