lm-form/lib/validate.js

* 作者：liuduan * 邮箱：liuduan.05.05@163.com * 版本：**`1.0.2`**

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
var _jsxFileName = 'src/validate.js';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _react = require('react');

var _react2 = _interopRequireDefault(_react);

var _validate = require('./validate.rule');

var _validate2 = _interopRequireDefault(_validate);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var ValidateHoc = function ValidateHoc(Form, rules) {

    var validRules = rules ? Object.assign({}, _validate2.default, rules) : _validate2.default;

    return function (_Component) {
        _inherits(ValidateHoc, _Component);

        function ValidateHoc(props) {
            _classCallCheck(this, ValidateHoc);

            var _this = _possibleConstructorReturn(this, (ValidateHoc.__proto__ || Object.getPrototypeOf(ValidateHoc)).call(this, props));

            _this.formValidate = _this.formValidate.bind(_this);
            _this.inputValidate = _this.inputValidate.bind(_this);

            _this.timer = null;
            return _this;
        }

        _createClass(ValidateHoc, [{
            key: 'componentWillUnmount',
            value: function componentWillUnmount() {
                clearTimeout(this.timer);
            }

            // 表单提交校验方法

        }, {
            key: 'formValidate',
            value: function formValidate() {
                var _this2 = this;

                var validData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];

                return new Promise(function (resolve, reject) {
                    var flag = true,
                        query = {},
                        msg = void 0;
                    var i = 0,
                        len = validData.length;

                    var _loop = function _loop() {
                        var item = validData[i];
                        var ref = item.ref,
                            name = item.name,
                            value = item.value,
                            rule = item.rule,
                            param = item.param,
                            required = item.required,
                            err = item.err,
                            requireMsg = item.requireMsg,
                            errMsg = item.errMsg;
                        // 判断是否需要验证

                        if (required || rule) {
                            var _inputValidate = _this2.inputValidate({ value: value, rule: rule, param: param, required: required, err: err, errMsg: errMsg, requireMsg: requireMsg }),
                                isValid = _inputValidate.isValid,
                                message = _inputValidate.message;

                            if (!isValid) {
                                _this2.validateRef.setState(_defineProperty({}, err, true));
                                // 自动选中错误项焦点，异步执行，防止先与onBlur事件执行
                                clearTimeout(_this2.timer);
                                _this2.timer = setTimeout(function () {
                                    if (ref && ref.inputRef) ref.inputRef.focus();
                                }, 0);
                                msg = message === 'required' && requireMsg ? requireMsg : message;
                                flag = false;
                                reject(msg);
                                return 'break';
                            }
                            // 验证通过将其添加到query中
                            if (name) query[name] = typeof value === "string" ? value.trim() : value;
                        }
                    };

                    for (i; i < len; i++) {
                        var _ret = _loop();

                        if (_ret === 'break') break;
                    }
                    // 校验成功 提交表单
                    if (flag) {
                        resolve(query);
                    }
                });
            }

            // errMsg 、 rule 统一为数组类型

        }, {
            key: 'stirngToArr',
            value: function stirngToArr(value) {
                if (typeof value === 'string' && value || Object.prototype.toString.call(value) === '[object Array]' && value.length || typeof value === 'function') {
                    return [].concat(value);
                } else {
                    return [];
                }
            }

            // input校验方法

        }, {
            key: 'inputValidate',
            value: function inputValidate(_ref) {
                var value = _ref.value,
                    rule = _ref.rule,
                    _ref$param = _ref.param,
                    param = _ref$param === undefined ? [] : _ref$param,
                    required = _ref.required,
                    err = _ref.err,
                    errMsg = _ref.errMsg;

                var isValid = true,
                    message = '',
                    rules = [],
                    errMsgs = [];
                // 支持 多种 规则校验
                rules = this.stirngToArr(rule);
                errMsgs = this.stirngToArr(errMsg);

                var noEmpty = Object.prototype.toString.call(value) === '[object Array]' && value.length || typeof value === 'string' && value !== '' || typeof value === 'number' || typeof value === 'boolean' && value;
                // 先判断是否必填
                if (!noEmpty && required) {
                    isValid = false;
                    message = 'required';
                    // 判断是否符合检验规则
                } else if (noEmpty && rules.length) {
                    var i = 0,
                        len = rules.length;

                    for (i; i < len; i++) {
                        // 现在已有的规则函数中查找，找不到，判断rule是不是函数
                        var validateFun = validRules[rules[i]] || rules[i];

                        if (validateFun && typeof validateFun === 'function') {

                            var validateObj = validateFun(value, param);

                            if (Object.prototype.toString.call(validateObj) === '[object Object]') {
                                isValid = !!validateObj.validator;
                                message = errMsgs[i] || validateObj.message || '输入不符合规则';
                            } else {
                                isValid = !!validateObj;
                                message = errMsgs[i] || '输入不符合规则';
                            }

                            // 如果验证通过但仍爆红，自动处理
                            if (err && isValid && this.validateRef.state[err]) this.validateRef.setState(_defineProperty({}, err, false));
                            // 如果验证没有通过直接返回
                            if (!isValid) break;
                        }
                    }
                } else if (noEmpty && rule instanceof RegExp) {
                    // 支持正值表达式直接校验
                    isValid = rule.test(value);
                    message = errMsgs[0] || '输入不符合规则';
                    // 如果验证通过但仍爆红，自动处理
                    if (err && isValid && this.validateRef.state[err]) this.validateRef.setState(_defineProperty({}, err, false));
                }
                return { isValid: isValid, message: message };
            }
        }, {
            key: 'render',
            value: function render() {
                var _this3 = this;

                var others = {
                    inputValidate: this.inputValidate
                };
                if (Form.name !== 'InputValidate') {
                    Object.assign(others, {
                        formValidate: this.formValidate
                    });
                }
                return _react2.default.createElement(Form, Object.assign({}, this.props, others, _defineProperty({ ref: function ref(el) {
                        return _this3.validateRef = el;
                    }, __source: {
                        fileName: _jsxFileName,
                        lineNumber: 129
                    },
                    __self: this
                }, '__self', this)));
            }
        }]);

        return ValidateHoc;
    }(_react.Component);
};

exports.default = ValidateHoc;
module.exports = exports['default'];