first commit

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/any.js

@@ -0,0 +1,14 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+  }
+  callback(errors);
+};
+export default any;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/array.js

@@ -0,0 +1,17 @@
+import rules from "../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();
+    }
+    rules.required(rule, value, source, errors, options, 'array');
+    if (value !== undefined && value !== null) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+export default array;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/boolean.js

@@ -0,0 +1,17 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+export default boolean;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/date.js

@@ -0,0 +1,28 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value, 'date') && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value, 'date')) {
+      var dateObject;
+      if (value instanceof Date) {
+        dateObject = value;
+      } else {
+        dateObject = new Date(value);
+      }
+      rules.type(rule, dateObject, source, errors, options);
+      if (dateObject) {
+        rules.range(rule, dateObject.getTime(), source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+};
+export default date;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/enum.js

@@ -0,0 +1,18 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules[ENUM](rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+export default enumerable;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/float.js

@@ -0,0 +1,18 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+export default floatFn;

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

@@ -0,0 +1,21 @@
+declare const _default: {
+    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;
+    tel: import("../interface").ExecuteValidator;
+    required: import("../interface").ExecuteValidator;
+    any: import("../interface").ExecuteValidator;
+};
+export default _default;

frontend/node_modules/@rc-component/async-validator/es/validator/index.js

@@ -0,0 +1,35 @@
+import any from "./any";
+import array from "./array";
+import boolean from "./boolean";
+import date from "./date";
+import enumValidator from "./enum";
+import float from "./float";
+import integer from "./integer";
+import method from "./method";
+import number from "./number";
+import object from "./object";
+import pattern from "./pattern";
+import regexp from "./regexp";
+import required from "./required";
+import string from "./string";
+import type from "./type";
+export default {
+  string: string,
+  method: method,
+  number: number,
+  boolean: boolean,
+  regexp: regexp,
+  integer: integer,
+  float: float,
+  array: array,
+  object: object,
+  enum: enumValidator,
+  pattern: pattern,
+  date: date,
+  url: type,
+  hex: type,
+  email: type,
+  tel: type,
+  required: required,
+  any: any
+};

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/integer.js

@@ -0,0 +1,18 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+export default integer;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/method.js

@@ -0,0 +1,17 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+export default method;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/number.js

@@ -0,0 +1,22 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+export default number;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/object.js

@@ -0,0 +1,17 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (value !== undefined) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+export default object;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/pattern.js

@@ -0,0 +1,17 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value, 'string') && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value, 'string')) {
+      rules.pattern(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+export default pattern;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/regexp.js

@@ -0,0 +1,17 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options);
+    if (!isEmptyValue(value)) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+export default regexp;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/required.js

@@ -0,0 +1,9 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import rules from "../rule";
+var required = function required(rule, value, callback, source, options) {
+  var errors = [];
+  var type = Array.isArray(value) ? 'array' : _typeof(value);
+  rules.required(rule, value, source, errors, options, type);
+  callback(errors);
+};
+export default required;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/string.js

@@ -0,0 +1,22 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value, 'string') && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options, 'string');
+    if (!isEmptyValue(value, 'string')) {
+      rules.type(rule, value, source, errors, options);
+      rules.range(rule, value, source, errors, options);
+      rules.pattern(rule, value, source, errors, options);
+      if (rule.whitespace === true) {
+        rules.whitespace(rule, value, source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+};
+export default string;

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

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

frontend/node_modules/@rc-component/async-validator/es/validator/type.js

@@ -0,0 +1,18 @@
+import rules from "../rule";
+import { isEmptyValue } from "../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 (isEmptyValue(value, ruleType) && !rule.required) {
+      return callback();
+    }
+    rules.required(rule, value, source, errors, options, ruleType);
+    if (!isEmptyValue(value, ruleType)) {
+      rules.type(rule, value, source, errors, options);
+    }
+  }
+  callback(errors);
+};
+export default type;