add all frontend files

node_modules/@rc-component/async-validator/lib/index.d.ts

@@ -0,0 +1,43 @@
+import type { InternalRuleItem, InternalValidateMessages, RuleItem, RuleType, Rules, SyncErrorType, ValidateCallback, ValidateMessages, ValidateOption, Values } from './interface';
+export * from './interface';
+/**
+ *  Encapsulates a validation schema.
+ *
+ *  @param descriptor An object declaring validation rules
+ *  for this schema.
+ */
+declare class Schema {
+    static register: (type: string, validator: any) => void;
+    static warning: (type: string, errors: SyncErrorType[]) => void;
+    static messages: InternalValidateMessages;
+    static validators: {
+        string: import("./interface").ExecuteValidator;
+        method: import("./interface").ExecuteValidator;
+        number: import("./interface").ExecuteValidator;
+        boolean: import("./interface").ExecuteValidator;
+        regexp: import("./interface").ExecuteValidator;
+        integer: import("./interface").ExecuteValidator;
+        float: import("./interface").ExecuteValidator;
+        array: import("./interface").ExecuteValidator;
+        object: import("./interface").ExecuteValidator;
+        enum: import("./interface").ExecuteValidator;
+        pattern: import("./interface").ExecuteValidator;
+        date: import("./interface").ExecuteValidator;
+        url: import("./interface").ExecuteValidator;
+        hex: import("./interface").ExecuteValidator;
+        email: import("./interface").ExecuteValidator;
+        required: import("./interface").ExecuteValidator;
+        any: import("./interface").ExecuteValidator;
+    };
+    rules: Record<string, RuleItem[]>;
+    _messages: InternalValidateMessages;
+    constructor(descriptor: Rules);
+    define(rules: Rules): void;
+    messages(messages?: ValidateMessages): InternalValidateMessages;
+    validate(source: Values, option?: ValidateOption, callback?: ValidateCallback): Promise<Values>;
+    validate(source: Values, callback: ValidateCallback): Promise<Values>;
+    validate(source: Values): Promise<Values>;
+    getType(rule: InternalRuleItem): RuleType;
+    getValidationMethod(rule: InternalRuleItem): import("./interface").ExecuteValidator | ((rule: InternalRuleItem, value: any, callback: (error?: string | Error) => void, source: Values, options: ValidateOption) => void | import("./interface").SyncValidateResult);
+}
+export default Schema;

node_modules/@rc-component/async-validator/lib/index.js

@@ -0,0 +1,310 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _messages2 = require("./messages");
+var _util = require("./util");
+var _index = _interopRequireDefault(require("./validator/index"));
+var _interface = require("./interface");
+Object.keys(_interface).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _interface[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _interface[key];
+    }
+  });
+});
+/**
+ *  Encapsulates a validation schema.
+ *
+ *  @param descriptor An object declaring validation rules
+ *  for this schema.
+ */
+var Schema = /*#__PURE__*/function () {
+  function Schema(descriptor) {
+    (0, _classCallCheck2.default)(this, Schema);
+    // ======================== Instance ========================
+    (0, _defineProperty2.default)(this, "rules", null);
+    (0, _defineProperty2.default)(this, "_messages", _messages2.messages);
+    this.define(descriptor);
+  }
+  (0, _createClass2.default)(Schema, [{
+    key: "define",
+    value: function define(rules) {
+      var _this = this;
+      if (!rules) {
+        throw new Error('Cannot configure a schema with no rules');
+      }
+      if ((0, _typeof2.default)(rules) !== 'object' || Array.isArray(rules)) {
+        throw new Error('Rules must be an object');
+      }
+      this.rules = {};
+      Object.keys(rules).forEach(function (name) {
+        var item = rules[name];
+        _this.rules[name] = Array.isArray(item) ? item : [item];
+      });
+    }
+  }, {
+    key: "messages",
+    value: function messages(_messages) {
+      if (_messages) {
+        this._messages = (0, _util.deepMerge)((0, _messages2.newMessages)(), _messages);
+      }
+      return this._messages;
+    }
+  }, {
+    key: "validate",
+    value: function validate(source_) {
+      var _this2 = this;
+      var o = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var oc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};
+      var source = source_;
+      var options = o;
+      var callback = oc;
+      if (typeof options === 'function') {
+        callback = options;
+        options = {};
+      }
+      if (!this.rules || Object.keys(this.rules).length === 0) {
+        if (callback) {
+          callback(null, source);
+        }
+        return Promise.resolve(source);
+      }
+      function complete(results) {
+        var errors = [];
+        var fields = {};
+        function add(e) {
+          if (Array.isArray(e)) {
+            var _errors;
+            errors = (_errors = errors).concat.apply(_errors, (0, _toConsumableArray2.default)(e));
+          } else {
+            errors.push(e);
+          }
+        }
+        for (var i = 0; i < results.length; i++) {
+          add(results[i]);
+        }
+        if (!errors.length) {
+          callback(null, source);
+        } else {
+          fields = (0, _util.convertFieldsError)(errors);
+          callback(errors, fields);
+        }
+      }
+      if (options.messages) {
+        var messages = this.messages();
+        if (messages === _messages2.messages) {
+          messages = (0, _messages2.newMessages)();
+        }
+        (0, _util.deepMerge)(messages, options.messages);
+        options.messages = messages;
+      } else {
+        options.messages = this.messages();
+      }
+      var series = {};
+      var keys = options.keys || Object.keys(this.rules);
+      keys.forEach(function (z) {
+        var arr = _this2.rules[z];
+        var value = source[z];
+        arr.forEach(function (r) {
+          var rule = r;
+          if (typeof rule.transform === 'function') {
+            if (source === source_) {
+              source = (0, _objectSpread2.default)({}, source);
+            }
+            value = source[z] = rule.transform(value);
+            if (value !== undefined && value !== null) {
+              rule.type = rule.type || (Array.isArray(value) ? 'array' : (0, _typeof2.default)(value));
+            }
+          }
+          if (typeof rule === 'function') {
+            rule = {
+              validator: rule
+            };
+          } else {
+            rule = (0, _objectSpread2.default)({}, rule);
+          }
+
+          // Fill validator. Skip if nothing need to validate
+          rule.validator = _this2.getValidationMethod(rule);
+          if (!rule.validator) {
+            return;
+          }
+          rule.field = z;
+          rule.fullField = rule.fullField || z;
+          rule.type = _this2.getType(rule);
+          series[z] = series[z] || [];
+          series[z].push({
+            rule: rule,
+            value: value,
+            source: source,
+            field: z
+          });
+        });
+      });
+      var errorFields = {};
+      return (0, _util.asyncMap)(series, options, function (data, doIt) {
+        var rule = data.rule;
+        var deep = (rule.type === 'object' || rule.type === 'array') && ((0, _typeof2.default)(rule.fields) === 'object' || (0, _typeof2.default)(rule.defaultField) === 'object');
+        deep = deep && (rule.required || !rule.required && data.value);
+        rule.field = data.field;
+        function addFullField(key, schema) {
+          return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, schema), {}, {
+            fullField: "".concat(rule.fullField, ".").concat(key),
+            fullFields: rule.fullFields ? [].concat((0, _toConsumableArray2.default)(rule.fullFields), [key]) : [key]
+          });
+        }
+        function cb() {
+          var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+          var errorList = Array.isArray(e) ? e : [e];
+          if (!options.suppressWarning && errorList.length) {
+            Schema.warning('async-validator:', errorList);
+          }
+          if (errorList.length && rule.message !== undefined) {
+            errorList = [].concat(rule.message);
+          }
+
+          // Fill error info
+          var filledErrors = errorList.map((0, _util.complementError)(rule, source));
+          if (options.first && filledErrors.length) {
+            errorFields[rule.field] = 1;
+            return doIt(filledErrors);
+          }
+          if (!deep) {
+            doIt(filledErrors);
+          } else {
+            // if rule is required but the target object
+            // does not exist fail at the rule level and don't
+            // go deeper
+            if (rule.required && !data.value) {
+              if (rule.message !== undefined) {
+                filledErrors = [].concat(rule.message).map((0, _util.complementError)(rule, source));
+              } else if (options.error) {
+                filledErrors = [options.error(rule, (0, _util.format)(options.messages.required, rule.field))];
+              }
+              return doIt(filledErrors);
+            }
+            var fieldsSchema = {};
+            if (rule.defaultField) {
+              Object.keys(data.value).map(function (key) {
+                fieldsSchema[key] = rule.defaultField;
+              });
+            }
+            fieldsSchema = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, fieldsSchema), data.rule.fields);
+            var paredFieldsSchema = {};
+            Object.keys(fieldsSchema).forEach(function (field) {
+              var fieldSchema = fieldsSchema[field];
+              var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
+              paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
+            });
+            var schema = new Schema(paredFieldsSchema);
+            schema.messages(options.messages);
+            if (data.rule.options) {
+              data.rule.options.messages = options.messages;
+              data.rule.options.error = options.error;
+            }
+            schema.validate(data.value, data.rule.options || options, function (errs) {
+              var finalErrors = [];
+              if (filledErrors && filledErrors.length) {
+                finalErrors.push.apply(finalErrors, (0, _toConsumableArray2.default)(filledErrors));
+              }
+              if (errs && errs.length) {
+                finalErrors.push.apply(finalErrors, (0, _toConsumableArray2.default)(errs));
+              }
+              doIt(finalErrors.length ? finalErrors : null);
+            });
+          }
+        }
+        var res;
+        if (rule.asyncValidator) {
+          res = rule.asyncValidator(rule, data.value, cb, data.source, options);
+        } else if (rule.validator) {
+          try {
+            res = rule.validator(rule, data.value, cb, data.source, options);
+          } catch (error) {
+            var _console$error, _console;
+            (_console$error = (_console = console).error) === null || _console$error === void 0 || _console$error.call(_console, error);
+            // rethrow to report error
+            if (!options.suppressValidatorError) {
+              setTimeout(function () {
+                throw error;
+              }, 0);
+            }
+            cb(error.message);
+          }
+          if (res === true) {
+            cb();
+          } else if (res === false) {
+            cb(typeof rule.message === 'function' ? rule.message(rule.fullField || rule.field) : rule.message || "".concat(rule.fullField || rule.field, " fails"));
+          } else if (res instanceof Array) {
+            cb(res);
+          } else if (res instanceof Error) {
+            cb(res.message);
+          }
+        }
+        if (res && res.then) {
+          res.then(function () {
+            return cb();
+          }, function (e) {
+            return cb(e);
+          });
+        }
+      }, function (results) {
+        complete(results);
+      }, source);
+    }
+  }, {
+    key: "getType",
+    value: function getType(rule) {
+      if (rule.type === undefined && rule.pattern instanceof RegExp) {
+        rule.type = 'pattern';
+      }
+      if (typeof rule.validator !== 'function' && rule.type && !_index.default.hasOwnProperty(rule.type)) {
+        throw new Error((0, _util.format)('Unknown rule type %s', rule.type));
+      }
+      return rule.type || 'string';
+    }
+  }, {
+    key: "getValidationMethod",
+    value: function getValidationMethod(rule) {
+      if (typeof rule.validator === 'function') {
+        return rule.validator;
+      }
+      var keys = Object.keys(rule);
+      var messageIndex = keys.indexOf('message');
+      if (messageIndex !== -1) {
+        keys.splice(messageIndex, 1);
+      }
+      if (keys.length === 1 && keys[0] === 'required') {
+        return _index.default.required;
+      }
+      return _index.default[this.getType(rule)] || undefined;
+    }
+  }]);
+  return Schema;
+}();
+// ========================= Static =========================
+(0, _defineProperty2.default)(Schema, "register", function register(type, validator) {
+  if (typeof validator !== 'function') {
+    throw new Error('Cannot register a validator by type, validator is not a function');
+  }
+  _index.default[type] = validator;
+});
+(0, _defineProperty2.default)(Schema, "warning", _util.warning);
+(0, _defineProperty2.default)(Schema, "messages", _messages2.messages);
+(0, _defineProperty2.default)(Schema, "validators", _index.default);
+var _default = exports.default = Schema;

node_modules/@rc-component/async-validator/lib/interface.d.ts

@@ -0,0 +1,135 @@
+export type RuleType = 'string' | 'number' | 'boolean' | 'method' | 'regexp' | 'integer' | 'float' | 'array' | 'object' | 'enum' | 'date' | 'url' | 'hex' | 'email' | 'pattern' | 'any';
+export interface ValidateOption {
+    suppressWarning?: boolean;
+    suppressValidatorError?: boolean;
+    first?: boolean;
+    firstFields?: boolean | string[];
+    messages?: Partial<ValidateMessages>;
+    /** The name of rules need to be trigger. Will validate all rules if leave empty */
+    keys?: string[];
+    error?: (rule: InternalRuleItem, message: string) => ValidateError;
+}
+export type SyncErrorType = Error | string;
+export type SyncValidateResult = boolean | SyncErrorType | SyncErrorType[];
+export type ValidateResult = void | Promise<void> | SyncValidateResult;
+export interface RuleItem {
+    type?: RuleType;
+    required?: boolean;
+    pattern?: RegExp | string;
+    min?: number;
+    max?: number;
+    len?: number;
+    enum?: (string | number | boolean | null | undefined)[];
+    whitespace?: boolean;
+    fields?: Record<string, Rule>;
+    options?: ValidateOption;
+    defaultField?: Rule;
+    transform?: (value: Value) => Value;
+    message?: string | ((a?: string) => string);
+    asyncValidator?: (rule: InternalRuleItem, value: Value, callback: (error?: string | Error) => void, source: Values, options: ValidateOption) => void | Promise<void>;
+    validator?: (rule: InternalRuleItem, value: Value, callback: (error?: string | Error) => void, source: Values, options: ValidateOption) => SyncValidateResult | void;
+}
+export type Rule = RuleItem | RuleItem[];
+export type Rules = Record<string, Rule>;
+/**
+ *  Rule for validating a value exists in an enumerable list.
+ *
+ *  @param rule The validation rule.
+ *  @param value The value of the field on the source object.
+ *  @param source The source object being validated.
+ *  @param errors An array of errors that this rule may add
+ *  validation errors to.
+ *  @param options The validation options.
+ *  @param options.messages The validation messages.
+ *  @param type Rule type
+ */
+export type ExecuteRule = (rule: InternalRuleItem, value: Value, source: Values, errors: string[], options: ValidateOption, type?: string) => void;
+/**
+ *  Performs validation for any type.
+ *
+ *  @param rule The validation rule.
+ *  @param value The value of the field on the source object.
+ *  @param callback The callback function.
+ *  @param source The source object being validated.
+ *  @param options The validation options.
+ *  @param options.messages The validation messages.
+ */
+export type ExecuteValidator = (rule: InternalRuleItem, value: Value, callback: (error?: string[]) => void, source: Values, options: ValidateOption) => void;
+type ValidateMessage<T extends any[] = unknown[]> = string | ((...args: T) => string);
+type FullField = string | undefined;
+type EnumString = string | undefined;
+type Pattern = string | RegExp | undefined;
+type Range = number | undefined;
+type Type = string | undefined;
+export interface ValidateMessages {
+    default?: ValidateMessage;
+    required?: ValidateMessage<[FullField]>;
+    enum?: ValidateMessage<[FullField, EnumString]>;
+    whitespace?: ValidateMessage<[FullField]>;
+    date?: {
+        format?: ValidateMessage;
+        parse?: ValidateMessage;
+        invalid?: ValidateMessage;
+    };
+    types?: {
+        string?: ValidateMessage<[FullField, Type]>;
+        method?: ValidateMessage<[FullField, Type]>;
+        array?: ValidateMessage<[FullField, Type]>;
+        object?: ValidateMessage<[FullField, Type]>;
+        number?: ValidateMessage<[FullField, Type]>;
+        date?: ValidateMessage<[FullField, Type]>;
+        boolean?: ValidateMessage<[FullField, Type]>;
+        integer?: ValidateMessage<[FullField, Type]>;
+        float?: ValidateMessage<[FullField, Type]>;
+        regexp?: ValidateMessage<[FullField, Type]>;
+        email?: ValidateMessage<[FullField, Type]>;
+        url?: ValidateMessage<[FullField, Type]>;
+        hex?: ValidateMessage<[FullField, Type]>;
+    };
+    string?: {
+        len?: ValidateMessage<[FullField, Range]>;
+        min?: ValidateMessage<[FullField, Range]>;
+        max?: ValidateMessage<[FullField, Range]>;
+        range?: ValidateMessage<[FullField, Range, Range]>;
+    };
+    number?: {
+        len?: ValidateMessage<[FullField, Range]>;
+        min?: ValidateMessage<[FullField, Range]>;
+        max?: ValidateMessage<[FullField, Range]>;
+        range?: ValidateMessage<[FullField, Range, Range]>;
+    };
+    array?: {
+        len?: ValidateMessage<[FullField, Range]>;
+        min?: ValidateMessage<[FullField, Range]>;
+        max?: ValidateMessage<[FullField, Range]>;
+        range?: ValidateMessage<[FullField, Range, Range]>;
+    };
+    pattern?: {
+        mismatch?: ValidateMessage<[FullField, Value, Pattern]>;
+    };
+}
+export interface InternalValidateMessages extends ValidateMessages {
+    clone: () => InternalValidateMessages;
+}
+export type Value = any;
+export type Values = Record<string, Value>;
+export interface ValidateError {
+    message?: string;
+    fieldValue?: Value;
+    field?: string;
+}
+export type ValidateFieldsError = Record<string, ValidateError[]>;
+export type ValidateCallback = (errors: ValidateError[] | null, fields: ValidateFieldsError | Values) => void;
+export interface RuleValuePackage {
+    rule: InternalRuleItem;
+    value: Value;
+    source: Values;
+    field: string;
+}
+export interface InternalRuleItem extends Omit<RuleItem, 'validator'> {
+    field?: string;
+    fullField?: string;
+    fullFields?: string[];
+    validator?: RuleItem['validator'] | ExecuteValidator;
+}
+export {};

node_modules/@rc-component/async-validator/lib/interface.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

node_modules/@rc-component/async-validator/lib/messages.d.ts

@@ -0,0 +1,3 @@
+import type { InternalValidateMessages } from './interface';
+export declare function newMessages(): InternalValidateMessages;
+export declare const messages: InternalValidateMessages;

node_modules/@rc-component/async-validator/lib/messages.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.messages = void 0;
+exports.newMessages = newMessages;
+function newMessages() {
+  return {
+    default: 'Validation error on field %s',
+    required: '%s is required',
+    enum: '%s must be one of %s',
+    whitespace: '%s cannot be empty',
+    date: {
+      format: '%s date %s is invalid for format %s',
+      parse: '%s date could not be parsed, %s is invalid ',
+      invalid: '%s date %s is invalid'
+    },
+    types: {
+      string: '%s is not a %s',
+      method: '%s is not a %s (function)',
+      array: '%s is not an %s',
+      object: '%s is not an %s',
+      number: '%s is not a %s',
+      date: '%s is not a %s',
+      boolean: '%s is not a %s',
+      integer: '%s is not an %s',
+      float: '%s is not a %s',
+      regexp: '%s is not a valid %s',
+      email: '%s is not a valid %s',
+      url: '%s is not a valid %s',
+      hex: '%s is not a valid %s'
+    },
+    string: {
+      len: '%s must be exactly %s characters',
+      min: '%s must be at least %s characters',
+      max: '%s cannot be longer than %s characters',
+      range: '%s must be between %s and %s characters'
+    },
+    number: {
+      len: '%s must equal %s',
+      min: '%s cannot be less than %s',
+      max: '%s cannot be greater than %s',
+      range: '%s must be between %s and %s'
+    },
+    array: {
+      len: '%s must be exactly %s in length',
+      min: '%s cannot be less than %s in length',
+      max: '%s cannot be greater than %s in length',
+      range: '%s must be between %s and %s in length'
+    },
+    pattern: {
+      mismatch: '%s value %s does not match pattern %s'
+    },
+    clone: function clone() {
+      var cloned = JSON.parse(JSON.stringify(this));
+      cloned.clone = this.clone;
+      return cloned;
+    }
+  };
+}
+var messages = exports.messages = newMessages();

node_modules/@rc-component/async-validator/lib/rule/enum.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteRule } from '../interface';
+declare const enumerable: ExecuteRule;
+export default enumerable;

node_modules/@rc-component/async-validator/lib/rule/enum.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _util = require("../util");
+var ENUM = 'enum';
+var enumerable = function enumerable(rule, value, source, errors, options) {
+  rule[ENUM] = Array.isArray(rule[ENUM]) ? rule[ENUM] : [];
+  if (rule[ENUM].indexOf(value) === -1) {
+    errors.push((0, _util.format)(options.messages[ENUM], rule.fullField, rule[ENUM].join(', ')));
+  }
+};
+var _default = exports.default = enumerable;

node_modules/@rc-component/async-validator/lib/rule/index.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    required: import("..").ExecuteRule;
+    whitespace: import("..").ExecuteRule;
+    type: import("..").ExecuteRule;
+    range: import("..").ExecuteRule;
+    enum: import("..").ExecuteRule;
+    pattern: import("..").ExecuteRule;
+};
+export default _default;

node_modules/@rc-component/async-validator/lib/rule/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _enum = _interopRequireDefault(require("./enum"));
+var _pattern = _interopRequireDefault(require("./pattern"));
+var _range = _interopRequireDefault(require("./range"));
+var _required = _interopRequireDefault(require("./required"));
+var _type = _interopRequireDefault(require("./type"));
+var _whitespace = _interopRequireDefault(require("./whitespace"));
+var _default = exports.default = {
+  required: _required.default,
+  whitespace: _whitespace.default,
+  type: _type.default,
+  range: _range.default,
+  enum: _enum.default,
+  pattern: _pattern.default
+};

node_modules/@rc-component/async-validator/lib/rule/pattern.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteRule } from '../interface';
+declare const pattern: ExecuteRule;
+export default pattern;

node_modules/@rc-component/async-validator/lib/rule/pattern.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _util = require("../util");
+var pattern = function pattern(rule, value, source, errors, options) {
+  if (rule.pattern) {
+    if (rule.pattern instanceof RegExp) {
+      // if a RegExp instance is passed, reset `lastIndex` in case its `global`
+      // flag is accidentally set to `true`, which in a validation scenario
+      // is not necessary and the result might be misleading
+      rule.pattern.lastIndex = 0;
+      if (!rule.pattern.test(value)) {
+        errors.push((0, _util.format)(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
+      }
+    } else if (typeof rule.pattern === 'string') {
+      var _pattern = new RegExp(rule.pattern);
+      if (!_pattern.test(value)) {
+        errors.push((0, _util.format)(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
+      }
+    }
+  }
+};
+var _default = exports.default = pattern;

node_modules/@rc-component/async-validator/lib/rule/range.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteRule } from '../interface';
+declare const range: ExecuteRule;
+export default range;

node_modules/@rc-component/async-validator/lib/rule/range.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _util = require("../util");
+var range = function range(rule, value, source, errors, options) {
+  var len = typeof rule.len === 'number';
+  var min = typeof rule.min === 'number';
+  var max = typeof rule.max === 'number';
+  // 正则匹配码点范围从U+010000一直到U+10FFFF的文字（补充平面Supplementary Plane）
+  var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  var val = value;
+  var key = null;
+  var num = typeof value === 'number';
+  var str = typeof value === 'string';
+  var arr = Array.isArray(value);
+  if (num) {
+    key = 'number';
+  } else if (str) {
+    key = 'string';
+  } else if (arr) {
+    key = 'array';
+  }
+  // if the value is not of a supported type for range validation
+  // the validation rule rule should use the
+  // type property to also test for a particular type
+  if (!key) {
+    return false;
+  }
+  if (arr) {
+    val = value.length;
+  }
+  if (str) {
+    // 处理码点大于U+010000的文字length属性不准确的bug，如"𠮷𠮷𠮷".length !== 3
+    val = value.replace(spRegexp, '_').length;
+  }
+  if (len) {
+    if (val !== rule.len) {
+      errors.push((0, _util.format)(options.messages[key].len, rule.fullField, rule.len));
+    }
+  } else if (min && !max && val < rule.min) {
+    errors.push((0, _util.format)(options.messages[key].min, rule.fullField, rule.min));
+  } else if (max && !min && val > rule.max) {
+    errors.push((0, _util.format)(options.messages[key].max, rule.fullField, rule.max));
+  } else if (min && max && (val < rule.min || val > rule.max)) {
+    errors.push((0, _util.format)(options.messages[key].range, rule.fullField, rule.min, rule.max));
+  }
+};
+var _default = exports.default = range;

node_modules/@rc-component/async-validator/lib/rule/required.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteRule } from '../interface';
+declare const required: ExecuteRule;
+export default required;

node_modules/@rc-component/async-validator/lib/rule/required.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _util = require("../util");
+var required = function required(rule, value, source, errors, options, type) {
+  if (rule.required && (!source.hasOwnProperty(rule.field) || (0, _util.isEmptyValue)(value, type || rule.type))) {
+    errors.push((0, _util.format)(options.messages.required, rule.fullField));
+  }
+};
+var _default = exports.default = required;

node_modules/@rc-component/async-validator/lib/rule/type.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteRule } from '../interface';
+declare const type: ExecuteRule;
+export default type;

node_modules/@rc-component/async-validator/lib/rule/type.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _util = require("../util");
+var _required = _interopRequireDefault(require("./required"));
+var _url = _interopRequireDefault(require("./url"));
+/* eslint max-len:0 */
+
+var pattern = {
+  // http://emailregex.com/
+  email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
+  // url: new RegExp(
+  //   '^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-*)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$',
+  //   'i',
+  // ),
+  hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
+};
+var types = {
+  integer: function integer(value) {
+    return types.number(value) && parseInt(value, 10) === value;
+  },
+  float: function float(value) {
+    return types.number(value) && !types.integer(value);
+  },
+  array: function array(value) {
+    return Array.isArray(value);
+  },
+  regexp: function regexp(value) {
+    if (value instanceof RegExp) {
+      return true;
+    }
+    try {
+      return !!new RegExp(value);
+    } catch (e) {
+      return false;
+    }
+  },
+  date: function date(value) {
+    return typeof value.getTime === 'function' && typeof value.getMonth === 'function' && typeof value.getYear === 'function' && !isNaN(value.getTime());
+  },
+  number: function number(value) {
+    if (isNaN(value)) {
+      return false;
+    }
+    return typeof value === 'number';
+  },
+  object: function object(value) {
+    return (0, _typeof2.default)(value) === 'object' && !types.array(value);
+  },
+  method: function method(value) {
+    return typeof value === 'function';
+  },
+  email: function email(value) {
+    return typeof value === 'string' && value.length <= 320 && !!value.match(pattern.email);
+  },
+  url: function url(value) {
+    return typeof value === 'string' && value.length <= 2048 && !!value.match((0, _url.default)());
+  },
+  hex: function hex(value) {
+    return typeof value === 'string' && !!value.match(pattern.hex);
+  }
+};
+var type = function type(rule, value, source, errors, options) {
+  if (rule.required && value === undefined) {
+    (0, _required.default)(rule, value, source, errors, options);
+    return;
+  }
+  var custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'number', 'date', 'url', 'hex'];
+  var ruleType = rule.type;
+  if (custom.indexOf(ruleType) > -1) {
+    if (!types[ruleType](value)) {
+      errors.push((0, _util.format)(options.messages.types[ruleType], rule.fullField, rule.type));
+    }
+    // straight typeof check
+  } else if (ruleType && (0, _typeof2.default)(value) !== rule.type) {
+    errors.push((0, _util.format)(options.messages.types[ruleType], rule.fullField, rule.type));
+  }
+};
+var _default = exports.default = type;

node_modules/@rc-component/async-validator/lib/rule/url.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => RegExp;
+export default _default;

node_modules/@rc-component/async-validator/lib/rule/url.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// https://github.com/kevva/url-regex/blob/master/index.js
+var urlReg;
+var _default = exports.default = function _default() {
+  if (urlReg) {
+    return urlReg;
+  }
+  var word = '[a-fA-F\\d:]';
+  var b = function b(options) {
+    return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=".concat(word, ")|(?<=").concat(word, ")(?=\\s|$))") : '';
+  };
+  var v4 = '(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}';
+  var v6seg = '[a-fA-F\\d]{1,4}';
+  var v6List = ["(?:".concat(v6seg, ":){7}(?:").concat(v6seg, "|:)"), // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
+  "(?:".concat(v6seg, ":){6}(?:").concat(v4, "|:").concat(v6seg, "|:)"), // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::
+  "(?:".concat(v6seg, ":){5}(?::").concat(v4, "|(?::").concat(v6seg, "){1,2}|:)"), // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::
+  "(?:".concat(v6seg, ":){4}(?:(?::").concat(v6seg, "){0,1}:").concat(v4, "|(?::").concat(v6seg, "){1,3}|:)"), // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::
+  "(?:".concat(v6seg, ":){3}(?:(?::").concat(v6seg, "){0,2}:").concat(v4, "|(?::").concat(v6seg, "){1,4}|:)"), // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::
+  "(?:".concat(v6seg, ":){2}(?:(?::").concat(v6seg, "){0,3}:").concat(v4, "|(?::").concat(v6seg, "){1,5}|:)"), // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::
+  "(?:".concat(v6seg, ":){1}(?:(?::").concat(v6seg, "){0,4}:").concat(v4, "|(?::").concat(v6seg, "){1,6}|:)"), // 1::              1::3:4:5:6:7:8   1::8            1::
+  "(?::(?:(?::".concat(v6seg, "){0,5}:").concat(v4, "|(?::").concat(v6seg, "){1,7}|:))") // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::
+  ];
+  var v6Eth0 = "(?:%[0-9a-zA-Z]{1,})?"; // %eth0            %1
+
+  var v6 = "(?:".concat(v6List.join('|'), ")").concat(v6Eth0);
+
+  // Pre-compile only the exact regexes because adding a global flag make regexes stateful
+  var v46Exact = new RegExp("(?:^".concat(v4, "$)|(?:^").concat(v6, "$)"));
+  var v4exact = new RegExp("^".concat(v4, "$"));
+  var v6exact = new RegExp("^".concat(v6, "$"));
+  var ip = function ip(options) {
+    return options && options.exact ? v46Exact : new RegExp("(?:".concat(b(options)).concat(v4).concat(b(options), ")|(?:").concat(b(options)).concat(v6).concat(b(options), ")"), 'g');
+  };
+  ip.v4 = function (options) {
+    return options && options.exact ? v4exact : new RegExp("".concat(b(options)).concat(v4).concat(b(options)), 'g');
+  };
+  ip.v6 = function (options) {
+    return options && options.exact ? v6exact : new RegExp("".concat(b(options)).concat(v6).concat(b(options)), 'g');
+  };
+  var protocol = "(?:(?:[a-z]+:)?//)";
+  var auth = '(?:\\S+(?::\\S*)?@)?';
+  var ipv4 = ip.v4().source;
+  var ipv6 = ip.v6().source;
+  var host = "(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)";
+  var domain = "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*";
+  var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))";
+  var port = '(?::\\d{2,5})?';
+  var path = '(?:[/?#][^\\s"]*)?';
+  var regex = "(?:".concat(protocol, "|www\\.)").concat(auth, "(?:localhost|").concat(ipv4, "|").concat(ipv6, "|").concat(host).concat(domain).concat(tld, ")").concat(port).concat(path);
+  urlReg = new RegExp("(?:^".concat(regex, "$)"), 'i');
+  return urlReg;
+};

node_modules/@rc-component/async-validator/lib/rule/whitespace.d.ts

@@ -0,0 +1,14 @@
+import type { ExecuteRule } from '../interface';
+/**
+ *  Rule for validating whitespace.
+ *
+ *  @param rule The validation rule.
+ *  @param value The value of the field on the source object.
+ *  @param source The source object being validated.
+ *  @param errors An array of errors that this rule may add
+ *  validation errors to.
+ *  @param options The validation options.
+ *  @param options.messages The validation messages.
+ */
+declare const whitespace: ExecuteRule;
+export default whitespace;

node_modules/@rc-component/async-validator/lib/rule/whitespace.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _util = require("../util");
+/**
+ *  Rule for validating whitespace.
+ *
+ *  @param rule The validation rule.
+ *  @param value The value of the field on the source object.
+ *  @param source The source object being validated.
+ *  @param errors An array of errors that this rule may add
+ *  validation errors to.
+ *  @param options The validation options.
+ *  @param options.messages The validation messages.
+ */
+var whitespace = function whitespace(rule, value, source, errors, options) {
+  if (/^\s+$/.test(value) || value === '') {
+    errors.push((0, _util.format)(options.messages.whitespace, rule.fullField));
+  }
+};
+var _default = exports.default = whitespace;

node_modules/@rc-component/async-validator/lib/util.d.ts

@@ -0,0 +1,16 @@
+import type { InternalRuleItem, RuleValuePackage, SyncErrorType, ValidateError, ValidateOption, Value, Values } from './interface';
+export declare let warning: (type: string, errors: SyncErrorType[]) => void;
+export declare function convertFieldsError(errors: ValidateError[]): Record<string, ValidateError[]>;
+export declare function format(template: ((...args: any[]) => string) | string, ...args: any[]): string;
+export declare function isEmptyValue(value: Value, type?: string): boolean;
+export declare function isEmptyObject(obj: object): boolean;
+export declare class AsyncValidationError extends Error {
+    errors: ValidateError[];
+    fields: Record<string, ValidateError[]>;
+    constructor(errors: ValidateError[], fields: Record<string, ValidateError[]>);
+}
+type ValidateFunc = (data: RuleValuePackage, doIt: (errors: ValidateError[]) => void) => void;
+export declare function asyncMap(objArr: Record<string, RuleValuePackage[]>, option: ValidateOption, func: ValidateFunc, callback: (errors: ValidateError[]) => void, source: Values): Promise<Values>;
+export declare function complementError(rule: InternalRuleItem, source: Values): (oe: ValidateError | (() => string) | string) => ValidateError;
+export declare function deepMerge<T extends object>(target: T, source: Partial<T>): T;
+export {};

node_modules/@rc-component/async-validator/lib/util.js

@@ -0,0 +1,259 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AsyncValidationError = void 0;
+exports.asyncMap = asyncMap;
+exports.complementError = complementError;
+exports.convertFieldsError = convertFieldsError;
+exports.deepMerge = deepMerge;
+exports.format = format;
+exports.isEmptyObject = isEmptyObject;
+exports.isEmptyValue = isEmptyValue;
+exports.warning = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+/* eslint no-console:0 */
+
+var formatRegExp = /%[sdj%]/g;
+var warning = exports.warning = function warning() {};
+
+// don't print warning message when in production env or node runtime
+if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV !== 'production' && typeof window !== 'undefined' && typeof document !== 'undefined') {
+  exports.warning = warning = function warning(type, errors) {
+    if (typeof console !== 'undefined' && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === 'undefined') {
+      if (errors.every(function (e) {
+        return typeof e === 'string';
+      })) {
+        console.warn(type, errors);
+      }
+    }
+  };
+}
+function convertFieldsError(errors) {
+  if (!errors || !errors.length) return null;
+  var fields = {};
+  errors.forEach(function (error) {
+    var field = error.field;
+    fields[field] = fields[field] || [];
+    fields[field].push(error);
+  });
+  return fields;
+}
+function format(template) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+  var i = 0;
+  var len = args.length;
+  if (typeof template === 'function') {
+    // eslint-disable-next-line prefer-spread
+    return template.apply(null, args);
+  }
+  if (typeof template === 'string') {
+    var str = template.replace(formatRegExp, function (x) {
+      if (x === '%%') {
+        return '%';
+      }
+      if (i >= len) {
+        return x;
+      }
+      switch (x) {
+        case '%s':
+          return String(args[i++]);
+        case '%d':
+          return Number(args[i++]);
+        case '%j':
+          try {
+            return JSON.stringify(args[i++]);
+          } catch (_) {
+            return '[Circular]';
+          }
+          break;
+        default:
+          return x;
+      }
+    });
+    return str;
+  }
+  return template;
+}
+function isNativeStringType(type) {
+  return type === 'string' || type === 'url' || type === 'hex' || type === 'email' || type === 'date' || type === 'pattern';
+}
+function isEmptyValue(value, type) {
+  if (value === undefined || value === null) {
+    return true;
+  }
+  if (type === 'array' && Array.isArray(value) && !value.length) {
+    return true;
+  }
+  if (isNativeStringType(type) && typeof value === 'string' && !value) {
+    return true;
+  }
+  return false;
+}
+function isEmptyObject(obj) {
+  return Object.keys(obj).length === 0;
+}
+function asyncParallelArray(arr, func, callback) {
+  var results = [];
+  var total = 0;
+  var arrLength = arr.length;
+  function count(errors) {
+    results.push.apply(results, (0, _toConsumableArray2.default)(errors || []));
+    total++;
+    if (total === arrLength) {
+      callback(results);
+    }
+  }
+  arr.forEach(function (a) {
+    func(a, count);
+  });
+}
+function asyncSerialArray(arr, func, callback) {
+  var index = 0;
+  var arrLength = arr.length;
+  function next(errors) {
+    if (errors && errors.length) {
+      callback(errors);
+      return;
+    }
+    var original = index;
+    index = index + 1;
+    if (original < arrLength) {
+      func(arr[original], next);
+    } else {
+      callback([]);
+    }
+  }
+  next([]);
+}
+function flattenObjArr(objArr) {
+  var ret = [];
+  Object.keys(objArr).forEach(function (k) {
+    ret.push.apply(ret, (0, _toConsumableArray2.default)(objArr[k] || []));
+  });
+  return ret;
+}
+var AsyncValidationError = exports.AsyncValidationError = /*#__PURE__*/function (_Error) {
+  (0, _inherits2.default)(AsyncValidationError, _Error);
+  var _super = (0, _createSuper2.default)(AsyncValidationError);
+  function AsyncValidationError(errors, fields) {
+    var _this;
+    (0, _classCallCheck2.default)(this, AsyncValidationError);
+    _this = _super.call(this, 'Async Validation Error');
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "errors", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "fields", void 0);
+    _this.errors = errors;
+    _this.fields = fields;
+    return _this;
+  }
+  return (0, _createClass2.default)(AsyncValidationError);
+}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
+function asyncMap(objArr, option, func, callback, source) {
+  if (option.first) {
+    var _pending = new Promise(function (resolve, reject) {
+      var next = function next(errors) {
+        callback(errors);
+        return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
+      };
+      var flattenArr = flattenObjArr(objArr);
+      asyncSerialArray(flattenArr, func, next);
+    });
+    _pending.catch(function (e) {
+      return e;
+    });
+    return _pending;
+  }
+  var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
+  var objArrKeys = Object.keys(objArr);
+  var objArrLength = objArrKeys.length;
+  var total = 0;
+  var results = [];
+  var pending = new Promise(function (resolve, reject) {
+    var next = function next(errors) {
+      // eslint-disable-next-line prefer-spread
+      results.push.apply(results, errors);
+      total++;
+      if (total === objArrLength) {
+        callback(results);
+        return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
+      }
+    };
+    if (!objArrKeys.length) {
+      callback(results);
+      resolve(source);
+    }
+    objArrKeys.forEach(function (key) {
+      var arr = objArr[key];
+      if (firstFields.indexOf(key) !== -1) {
+        asyncSerialArray(arr, func, next);
+      } else {
+        asyncParallelArray(arr, func, next);
+      }
+    });
+  });
+  pending.catch(function (e) {
+    return e;
+  });
+  return pending;
+}
+function isErrorObj(obj) {
+  return !!(obj && obj.message !== undefined);
+}
+function getValue(value, path) {
+  var v = value;
+  for (var i = 0; i < path.length; i++) {
+    if (v == undefined) {
+      return v;
+    }
+    v = v[path[i]];
+  }
+  return v;
+}
+function complementError(rule, source) {
+  return function (oe) {
+    var fieldValue;
+    if (rule.fullFields) {
+      fieldValue = getValue(source, rule.fullFields);
+    } else {
+      fieldValue = source[oe.field || rule.fullField];
+    }
+    if (isErrorObj(oe)) {
+      oe.field = oe.field || rule.fullField;
+      oe.fieldValue = fieldValue;
+      return oe;
+    }
+    return {
+      message: typeof oe === 'function' ? oe() : oe,
+      fieldValue: fieldValue,
+      field: oe.field || rule.fullField
+    };
+  };
+}
+function deepMerge(target, source) {
+  if (source) {
+    for (var s in source) {
+      if (source.hasOwnProperty(s)) {
+        var value = source[s];
+        if ((0, _typeof2.default)(value) === 'object' && (0, _typeof2.default)(target[s]) === 'object') {
+          target[s] = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, target[s]), value);
+        } else {
+          target[s] = value;
+        }
+      }
+    }
+  }
+  return target;
+}

node_modules/@rc-component/async-validator/lib/validator/any.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const any: ExecuteValidator;
+export default any;

node_modules/@rc-component/async-validator/lib/validator/any.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var any = function any(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value) && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options);
+  }
+  callback(errors);
+};
+var _default = exports.default = any;

node_modules/@rc-component/async-validator/lib/validator/array.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const array: ExecuteValidator;
+export default array;

node_modules/@rc-component/async-validator/lib/validator/array.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _index = _interopRequireDefault(require("../rule/index"));
+var array = function array(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((value === undefined || value === null) && !rule.required) {
+      return callback();
+    }
+    _index.default.required(rule, value, source, errors, options, 'array');
+    if (value !== undefined && value !== null) {
+      _index.default.type(rule, value, source, errors, options);
+      _index.default.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = array;

node_modules/@rc-component/async-validator/lib/validator/boolean.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const boolean: ExecuteValidator;
+export default boolean;

node_modules/@rc-component/async-validator/lib/validator/boolean.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var boolean = function boolean(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value) && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      _rule.default.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = boolean;

node_modules/@rc-component/async-validator/lib/validator/date.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const date: ExecuteValidator;
+export default date;

node_modules/@rc-component/async-validator/lib/validator/date.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var date = function date(rule, value, callback, source, options) {
+  // console.log('integer rule called %j', rule);
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  // console.log('validate on %s value', value);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value, 'date') && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options);
+    if (!(0, _util.isEmptyValue)(value, 'date')) {
+      var dateObject;
+      if (value instanceof Date) {
+        dateObject = value;
+      } else {
+        dateObject = new Date(value);
+      }
+      _rule.default.type(rule, dateObject, source, errors, options);
+      if (dateObject) {
+        _rule.default.range(rule, dateObject.getTime(), source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = date;

node_modules/@rc-component/async-validator/lib/validator/enum.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const enumerable: ExecuteValidator;
+export default enumerable;

node_modules/@rc-component/async-validator/lib/validator/enum.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var ENUM = 'enum';
+var enumerable = function enumerable(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value) && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      _rule.default[ENUM](rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = enumerable;

node_modules/@rc-component/async-validator/lib/validator/float.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const floatFn: ExecuteValidator;
+export default floatFn;

node_modules/@rc-component/async-validator/lib/validator/float.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var floatFn = function floatFn(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value) && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      _rule.default.type(rule, value, source, errors, options);
+      _rule.default.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = floatFn;

node_modules/@rc-component/async-validator/lib/validator/index.d.ts

@@ -0,0 +1,20 @@
+declare const _default: {
+    string: import("..").ExecuteValidator;
+    method: import("..").ExecuteValidator;
+    number: import("..").ExecuteValidator;
+    boolean: import("..").ExecuteValidator;
+    regexp: import("..").ExecuteValidator;
+    integer: import("..").ExecuteValidator;
+    float: import("..").ExecuteValidator;
+    array: import("..").ExecuteValidator;
+    object: import("..").ExecuteValidator;
+    enum: import("..").ExecuteValidator;
+    pattern: import("..").ExecuteValidator;
+    date: import("..").ExecuteValidator;
+    url: import("..").ExecuteValidator;
+    hex: import("..").ExecuteValidator;
+    email: import("..").ExecuteValidator;
+    required: import("..").ExecuteValidator;
+    any: import("..").ExecuteValidator;
+};
+export default _default;

node_modules/@rc-component/async-validator/lib/validator/index.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _any = _interopRequireDefault(require("./any"));
+var _array = _interopRequireDefault(require("./array"));
+var _boolean = _interopRequireDefault(require("./boolean"));
+var _date = _interopRequireDefault(require("./date"));
+var _enum = _interopRequireDefault(require("./enum"));
+var _float = _interopRequireDefault(require("./float"));
+var _integer = _interopRequireDefault(require("./integer"));
+var _method = _interopRequireDefault(require("./method"));
+var _number = _interopRequireDefault(require("./number"));
+var _object = _interopRequireDefault(require("./object"));
+var _pattern = _interopRequireDefault(require("./pattern"));
+var _regexp = _interopRequireDefault(require("./regexp"));
+var _required = _interopRequireDefault(require("./required"));
+var _string = _interopRequireDefault(require("./string"));
+var _type = _interopRequireDefault(require("./type"));
+var _default = exports.default = {
+  string: _string.default,
+  method: _method.default,
+  number: _number.default,
+  boolean: _boolean.default,
+  regexp: _regexp.default,
+  integer: _integer.default,
+  float: _float.default,
+  array: _array.default,
+  object: _object.default,
+  enum: _enum.default,
+  pattern: _pattern.default,
+  date: _date.default,
+  url: _type.default,
+  hex: _type.default,
+  email: _type.default,
+  required: _required.default,
+  any: _any.default
+};

node_modules/@rc-component/async-validator/lib/validator/integer.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const integer: ExecuteValidator;
+export default integer;

node_modules/@rc-component/async-validator/lib/validator/integer.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var integer = function integer(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value) && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      _rule.default.type(rule, value, source, errors, options);
+      _rule.default.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = integer;

node_modules/@rc-component/async-validator/lib/validator/method.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const method: ExecuteValidator;
+export default method;

node_modules/@rc-component/async-validator/lib/validator/method.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var method = function method(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value) && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      _rule.default.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = method;

node_modules/@rc-component/async-validator/lib/validator/number.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const number: ExecuteValidator;
+export default number;

node_modules/@rc-component/async-validator/lib/validator/number.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var number = function number(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if (value === '') {
+      // eslint-disable-next-line no-param-reassign
+      value = undefined;
+    }
+    if ((0, _util.isEmptyValue)(value) && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      _rule.default.type(rule, value, source, errors, options);
+      _rule.default.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = number;

node_modules/@rc-component/async-validator/lib/validator/object.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const object: ExecuteValidator;
+export default object;

node_modules/@rc-component/async-validator/lib/validator/object.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var object = function object(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value) && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      _rule.default.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = object;

node_modules/@rc-component/async-validator/lib/validator/pattern.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const pattern: ExecuteValidator;
+export default pattern;

node_modules/@rc-component/async-validator/lib/validator/pattern.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var pattern = function pattern(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value, 'string') && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options);
+    if (!(0, _util.isEmptyValue)(value, 'string')) {
+      _rule.default.pattern(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = pattern;

node_modules/@rc-component/async-validator/lib/validator/regexp.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const regexp: ExecuteValidator;
+export default regexp;

node_modules/@rc-component/async-validator/lib/validator/regexp.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var regexp = function regexp(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value) && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options);
+    if (!(0, _util.isEmptyValue)(value)) {
+      _rule.default.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = regexp;

node_modules/@rc-component/async-validator/lib/validator/required.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const required: ExecuteValidator;
+export default required;

node_modules/@rc-component/async-validator/lib/validator/required.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _rule = _interopRequireDefault(require("../rule"));
+var required = function required(rule, value, callback, source, options) {
+  var errors = [];
+  var type = Array.isArray(value) ? 'array' : (0, _typeof2.default)(value);
+  _rule.default.required(rule, value, source, errors, options, type);
+  callback(errors);
+};
+var _default = exports.default = required;

node_modules/@rc-component/async-validator/lib/validator/string.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const string: ExecuteValidator;
+export default string;

node_modules/@rc-component/async-validator/lib/validator/string.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var string = function string(rule, value, callback, source, options) {
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value, 'string') && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options, 'string');
+    if (!(0, _util.isEmptyValue)(value, 'string')) {
+      _rule.default.type(rule, value, source, errors, options);
+      _rule.default.range(rule, value, source, errors, options);
+      _rule.default.pattern(rule, value, source, errors, options);
+      if (rule.whitespace === true) {
+        _rule.default.whitespace(rule, value, source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = string;

node_modules/@rc-component/async-validator/lib/validator/type.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteValidator } from '../interface';
+declare const type: ExecuteValidator;
+export default type;

node_modules/@rc-component/async-validator/lib/validator/type.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _rule = _interopRequireDefault(require("../rule"));
+var _util = require("../util");
+var type = function type(rule, value, callback, source, options) {
+  var ruleType = rule.type;
+  var errors = [];
+  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
+  if (validate) {
+    if ((0, _util.isEmptyValue)(value, ruleType) && !rule.required) {
+      return callback();
+    }
+    _rule.default.required(rule, value, source, errors, options, ruleType);
+    if (!(0, _util.isEmptyValue)(value, ruleType)) {
+      _rule.default.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+var _default = exports.default = type;