@carrot-farm/mongsil-ui/dist/cjs/utils/validator.js

react ui library

"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);
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateModel = exports.validate = void 0;
var validate = function (rules, value) {
    var result = {
        pass: true,
        message: undefined,
    };
    // # 검사
    rules.forEach(function (_a) {
        var rule = _a.rule, message = _a.message;
        if (result.pass === false) {
            return;
        }
        var _rule = rule[0], options = rule.slice(1);
        if (pass.route(_rule, value, options) ===
            false) {
            result.pass = false;
            result.message = message;
        }
        // console.log('> pass: ', checked);
    });
    return result;
};
exports.validate = validate;
/** model전체를 검사한다 */
var validateModel = function (model, values) {
    var result = [];
    model.forEach(function (a) {
        var newRules = a.rules ? __spreadArray([], a.rules, true) : [];
        var curValue = values[a.name || ''];
        if (a.required === true) {
            newRules.push({ rule: ['required'], message: '' });
        }
        var _a = (0, exports.validate)(newRules, curValue), pass = _a.pass, message = _a.message;
        if (pass === false) {
            result.push(__assign(__assign({}, a), { error: {
                    pass: pass,
                    message: message,
                } }));
        }
    });
    return result;
};
exports.validateModel = validateModel;
/** `true`리턴 시 통과, false 리턴 시 실패 */
var pass = {
    required: function (value) { return (Array.isArray(value) ? value.length > 0 : !!value); },
    length: function (value, _a) {
        var _b = _a === void 0 ? [1, undefined] : _a, min = _b[0], max = _b[1];
        if (!min) {
            throw new Error("not defined min: " + (min ? min : ''));
        }
        // console.log('> length: ', value, value.length, min, max);
        if (typeof value === 'string' || Array.isArray(value)) {
            if (min) {
                if (value.length >= min) {
                    if (max) {
                        return value.length <= max;
                    }
                    return true;
                }
                else {
                    return false;
                }
            }
        }
        return false;
    },
    min: function (value, _a) {
        var min = _a[0];
        return Number(value) >= min;
    },
    max: function (value, _a) {
        var max = _a[0];
        return Number(value) <= max;
    },
    route: function (rule, value, options) {
        switch (rule) {
            case 'required':
                return pass.required(value);
            case 'length':
                return pass.length(value, options);
            case 'min':
                return pass.min(value, options);
            case 'max':
                return pass.min(value, options);
            default:
                throw new Error('invalid rule: ');
        }
    },
};