@valuer/main/dist/modules/validators.js

Valuer is an advanced declarative value validator

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var help_1 = require("@valuer/help");
var is_1 = require("@valuer/is");
var fn_1 = require("@valuer/fn");
var constants_1 = require("../constants");
var helpers_1 = require("../helpers");
var errors_1 = require("./errors");
// ***
/** @private */
var VALIDATOR_TO_DEFAULT_VALIDATION_MAP = Object.freeze({
    value: undefined,
    equals: undefined,
    set: undefined,
    kind: "any",
    composite: undefined,
    typeOf: undefined,
    instanceOf: undefined,
    number: "any",
    spectrum: "any",
    range: Object.freeze([-Infinity, Infinity]),
    pattern: /(?:)/,
    length: undefined,
    lengthRange: Object.freeze([0, Infinity]),
});
/** @private */
var VALIDATOR_STRING_TO_VALIDATION_STRING_LIST_MAP = {
    kind: [
        "any", "composite", "primitive", "void",
        "primitive-non-void", "composite-non-void", "non-void",
        "primitive-defined", "composite-defined", "defined",
        "primitive-non-null", "composite-non-null", "non-null",
    ],
    typeOf: [
        "string", "number", "boolean", "symbol", "undefined", "object", "function",
    ],
    number: [
        "any", "number", "numeric", "finite", "non-integer", "non-integer-finite",
        "integer", "integer-even", "integer-odd",
        "integer-safe", "integer-even-safe", "integer-odd-safe",
    ],
    spectrum: [
        "any", "number", "positive", "negative", "non-positive", "non-negative", "non-zero",
    ],
};
/** @private */
var VALIDATOR_TO_META_VALIDATOR_THUNK_MAP = __assign(__assign({}, help_1.help.convertMapFlat(VALIDATOR_STRING_TO_VALIDATION_STRING_LIST_MAP, is_1.is.inArray)), { value: is_1.is._any, equals: is_1.is._any, set: is_1.is.array(), composite: fn_1.fn.all(is_1.is.directInstanceOf(Object), function (object) { return Object.values(object).every(is_1.is._nonVoidComposite); }), instanceOf: is_1.is._function, range: is_1.is.array(2, is_1.is.numeric()), pattern: is_1.is.instanceOf(RegExp), length: is_1.is.natural(), lengthRange: is_1.is.lengthRange() });
/** @private */
var VALIDATOR_TO_VALIDATOR_FAILURE_MAP = __assign(__assign({}, help_1.help.convertMapFlat(VALIDATOR_STRING_TO_VALIDATION_STRING_LIST_MAP, function () { return constants_1.UNKNOWN_STRING_FAILURE; })), { value: null, equals: null, set: "is not an array", composite: "is not a map of descriptors", instanceOf: "is not a class", range: "is invalid range", pattern: "is not a regular expression", length: "is not a natural number", lengthRange: "is invalid length range" });
// ***
/** @private */
var isValidatorString = function (validator) {
    return validator in VALIDATOR_STRING_TO_VALIDATION_STRING_LIST_MAP;
};
// ***
/** @internal */
exports.Validators = {
    default: VALIDATOR_TO_DEFAULT_VALIDATION_MAP,
    // ***
    isValidationString: function (validation, validator) {
        var map = VALIDATOR_STRING_TO_VALIDATION_STRING_LIST_MAP;
        if (validator != null)
            return is_1.is.inArray(map[validator])(validation);
        else
            for (var _validator in map)
                if (exports.Validators.isValidationString(validation, _validator))
                    return true;
        return false;
    },
    isValidator: function (validator) {
        return validator in VALIDATOR_TO_DEFAULT_VALIDATION_MAP;
    },
    getFor: function (validation, index) {
        var map = VALIDATOR_STRING_TO_VALIDATION_STRING_LIST_MAP;
        var validators = [];
        for (var validator in map)
            if (is_1.is._any(validator))
                if (exports.Validators.isValidationString(validation, validator))
                    validators.push(validator);
        if (!validators.length)
            return errors_1.Errors.unknown.validation(validation, index);
        else
            return validators;
    },
    validate: function (validator, validation) {
        var thunk = VALIDATOR_TO_META_VALIDATOR_THUNK_MAP[validator];
        var invalid = function () { return errors_1.Errors.panic("Invalid validator", "\"" + validator + "\" " + VALIDATOR_TO_VALIDATOR_FAILURE_MAP[validator], "validation " + help_1.help.getPrintable(validation)); };
        if (isValidatorString(validator)) {
            if (!exports.Validators.isValidationString(validation, validator))
                return invalid();
        }
        else if (!thunk(validation))
            return invalid();
    },
    validateThunk: function (validation) {
        if (helpers_1.isThunk(validation))
            return validation;
        else
            return errors_1.Errors.panic("Invalid validator", "\"(custom)\" is not a thunk", "validation " + help_1.help.getPrintable(validation));
    },
};