@opentiny/vue-renderless 3.6.0 → 3.6.1-alpha.2

package/common/type.js

@@ -1,46 +1,39 @@
-export var toString = Object.prototype.toString;
-export var hasOwn = Object.prototype.hasOwnProperty;
-var getProto = Object.getPrototypeOf;
-var fnToString = hasOwn.toString;
-var ObjectFunctionString = fnToString.call(Object);
-var class2type = {
-  '[object Error]': 'error',
-  '[object Object]': 'object',
-  '[object RegExp]': 'regExp',
-  '[object Date]': 'date',
-  '[object Array]': 'array',
-  '[object Function]': 'function',
-  '[object String]': 'string',
-  '[object Number]': 'number',
-  '[object Boolean]': 'boolean'
-};
-export var isNull = function isNull(x) {
-  return x === null || x === undefined || x === 'undefined';
-};
-export var typeOf = function typeOf(obj) {
-  return isNull(obj) ? String(obj) : class2type[toString.call(obj)] || 'object';
-};
-export var isObject = function isObject(obj) {
-  return typeOf(obj) === 'object';
-};
-export var isFunction = function isFunction(fn) {
-  return typeOf(fn) === 'function';
-};
-export var isPlainObject = function isPlainObject(obj) {
-  if (!obj || toString.call(obj) !== '[object Object]') {
+import "../chunk-PKUHTIDK.js";
+const toString = Object.prototype.toString;
+const hasOwn = Object.prototype.hasOwnProperty;
+const getProto = Object.getPrototypeOf;
+const fnToString = hasOwn.toString;
+const ObjectFunctionString = fnToString.call(Object);
+const class2type = {
+  "[object Error]": "error",
+  "[object Object]": "object",
+  "[object RegExp]": "regExp",
+  "[object Date]": "date",
+  "[object Array]": "array",
+  "[object Function]": "function",
+  "[object String]": "string",
+  "[object Number]": "number",
+  "[object Boolean]": "boolean"
+};
+const isNull = (x) => x === null || x === void 0 || x === "undefined";
+const typeOf = (obj) => isNull(obj) ? String(obj) : class2type[toString.call(obj)] || "object";
+const isObject = (obj) => typeOf(obj) === "object";
+const isFunction = (fn) => typeOf(fn) === "function";
+const isPlainObject = (obj) => {
+  if (!obj || toString.call(obj) !== "[object Object]") {
     return false;
   }
-  var proto = getProto(obj);
+  const proto = getProto(obj);
   if (!proto) {
     return true;
   }
-  var Ctor = hasOwn.call(proto, 'constructor') && proto.constructor;
-  return typeof Ctor === 'function' && fnToString.call(Ctor) === ObjectFunctionString;
+  const Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
 };
-export var isEmptyObject = function isEmptyObject(obj) {
-  var type = typeOf(obj);
-  if (type === 'object' || type === 'array') {
-    for (var name in obj) {
+const isEmptyObject = (obj) => {
+  const type = typeOf(obj);
+  if (type === "object" || type === "array") {
+    for (const name in obj) {
       if (hasOwn.call(obj, name)) {
         return false;
       }
@@ -48,18 +41,23 @@ export var isEmptyObject = function isEmptyObject(obj) {
   }
   return true;
 };
-export var isNumber = function isNumber(value) {
-  return typeof value === 'number' && isFinite(value);
-};
-export var isNumeric = function isNumeric(value) {
-  return value - parseFloat(value) >= 0;
-};
-export var isDate = function isDate(value) {
-  return typeOf(value) === 'date';
-};
-export var isSame = function isSame(x, y) {
-  return x === y || typeof x === 'number' && typeof y === 'number' && isNaN(x) && isNaN(y);
+const isNumber = (value) => typeof value === "number" && isFinite(value);
+const isNumeric = (value) => value - parseFloat(value) >= 0;
+const isDate = (value) => typeOf(value) === "date";
+const isSame = (x, y) => x === y || typeof x === "number" && typeof y === "number" && isNaN(x) && isNaN(y);
+const isRegExp = (value) => typeOf(value) === "regExp";
+export {
+  hasOwn,
+  isDate,
+  isEmptyObject,
+  isFunction,
+  isNull,
+  isNumber,
+  isNumeric,
+  isObject,
+  isPlainObject,
+  isRegExp,
+  isSame,
+  toString,
+  typeOf
 };
-export var isRegExp = function isRegExp(value) {
-  return typeOf(value) === 'regExp';
-};

package/common/validate/index.js

@@ -1,6 +1,10 @@
-import Schema from './schema';
-import validators from './validations/index';
-import getDefaultMessage from './messages';
+import "../../chunk-PKUHTIDK.js";
+import Schema from "./schema";
+import validators from "./validations/index";
+import getDefaultMessage from "./messages";
 Schema.validators = validators;
 Schema.getDefaultMessage = getDefaultMessage;
-export default Schema;
+var validate_default = Schema;
+export {
+  validate_default as default
+};

package/common/validate/messages.js

@@ -1,68 +1,65 @@
-var getTypesObj = function getTypesObj(translate) {
-  return {
-    string: translate('validation.types.string'),
-    method: translate('validation.types.method'),
-    array: translate('validation.types.array'),
-    object: translate('validation.types.object'),
-    number: translate('validation.types.number'),
-    date: translate('validation.types.date'),
-    "boolean": translate('validation.types.boolean'),
-    integer: translate('validation.types.integer'),
-    "float": translate('validation.types.float'),
-    regexp: translate('validation.types.regexp'),
-    email: translate('validation.types.email'),
-    url: translate('validation.types.url'),
-    hex: translate('validation.types.hex'),
-    digits: translate('validation.types.digits'),
-    time: translate('validation.types.time'),
-    dateYM: translate('validation.types.dateYM'),
-    dateYMD: translate('validation.types.dateYMD'),
-    dateTime: translate('validation.types.dateTime'),
-    longDateTime: translate('validation.types.longDateTime'),
-    version: translate('validation.types.version'),
-    speczh: translate('validation.types.speczh'),
-    specialch: translate('validation.types.specialch'),
-    specialch2: translate('validation.types.hex'),
-    acceptImg: translate('validation.types.acceptImg'),
-    acceptFile: translate('validation.types.acceptFile'),
-    fileSize: translate('validation.types.fileSize')
-  };
+import "../../chunk-PKUHTIDK.js";
+const getTypesObj = (translate) => ({
+  string: translate("validation.types.string"),
+  method: translate("validation.types.method"),
+  array: translate("validation.types.array"),
+  object: translate("validation.types.object"),
+  number: translate("validation.types.number"),
+  date: translate("validation.types.date"),
+  boolean: translate("validation.types.boolean"),
+  integer: translate("validation.types.integer"),
+  float: translate("validation.types.float"),
+  regexp: translate("validation.types.regexp"),
+  email: translate("validation.types.email"),
+  url: translate("validation.types.url"),
+  hex: translate("validation.types.hex"),
+  digits: translate("validation.types.digits"),
+  time: translate("validation.types.time"),
+  dateYM: translate("validation.types.dateYM"),
+  dateYMD: translate("validation.types.dateYMD"),
+  dateTime: translate("validation.types.dateTime"),
+  longDateTime: translate("validation.types.longDateTime"),
+  version: translate("validation.types.version"),
+  speczh: translate("validation.types.speczh"),
+  specialch: translate("validation.types.specialch"),
+  specialch2: translate("validation.types.hex"),
+  acceptImg: translate("validation.types.acceptImg"),
+  acceptFile: translate("validation.types.acceptFile"),
+  fileSize: translate("validation.types.fileSize")
+});
+var messages_default = (translate = (value) => value) => ({
+  default: translate("validation.default"),
+  required: translate("validation.required"),
+  enum: translate("validation.enum"),
+  whitespace: translate("validation.whitespace"),
+  date: {
+    format: translate("validation.date.format"),
+    parse: translate("validation.date.parse"),
+    invalid: translate("validation.date.invalid")
+  },
+  types: getTypesObj(translate),
+  string: {
+    len: translate("validation.string.len"),
+    min: translate("validation.string.min"),
+    max: translate("validation.string.max"),
+    range: translate("validation.string.range")
+  },
+  number: {
+    len: translate("validation.number.len"),
+    min: translate("validation.number.min"),
+    max: translate("validation.number.max"),
+    range: translate("validation.number.range")
+  },
+  array: {
+    len: translate("validation.array.len"),
+    min: translate("validation.array.min"),
+    max: translate("validation.array.max"),
+    range: translate("validation.array.range")
+  },
+  pattern: {
+    mismatch: translate("validation.pattern.mismatch")
+  }
+});
+export {
+  messages_default as default
 };
-export default (function () {
-  var translate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function (value) {
-    return value;
-  };
-  return {
-    "default": translate('validation.default'),
-    required: translate('validation.required'),
-    "enum": translate('validation.enum'),
-    whitespace: translate('validation.whitespace'),
-    date: {
-      format: translate('validation.date.format'),
-      parse: translate('validation.date.parse'),
-      invalid: translate('validation.date.invalid')
-    },
-    types: getTypesObj(translate),
-    string: {
-      len: translate('validation.string.len'),
-      min: translate('validation.string.min'),
-      max: translate('validation.string.max'),
-      range: translate('validation.string.range')
-    },
-    number: {
-      len: translate('validation.number.len'),
-      min: translate('validation.number.min'),
-      max: translate('validation.number.max'),
-      range: translate('validation.number.range')
-    },
-    array: {
-      len: translate('validation.array.len'),
-      min: translate('validation.array.min'),
-      max: translate('validation.array.max'),
-      range: translate('validation.array.range')
-    },
-    pattern: {
-      mismatch: translate('validation.pattern.mismatch')
-    }
-  };
-});

package/common/validate/rules/enum.js

@@ -1,8 +1,12 @@
-import * as util from '../util';
-var ENUM = 'enum';
-export default function (rule, checkValue, source, errors, options) {
+import "../../../chunk-PKUHTIDK.js";
+import * as util from "../util";
+const ENUM = "enum";
+function enum_default(rule, checkValue, source, errors, options) {
   rule[ENUM] = Array.isArray(rule[ENUM]) ? rule[ENUM] : [];
-  if (rule[ENUM].indexOf(checkValue) === -1) {
-    errors.push(util.format(options.messages[ENUM], rule.fullField, rule[ENUM].join(', ')));
+  if (!rule[ENUM].includes(checkValue)) {
+    errors.push(util.format(options.messages[ENUM], rule.fullField, rule[ENUM].join(", ")));
   }
-}
+}
+export {
+  enum_default as default
+};

package/common/validate/rules/index.js

@@ -1,14 +1,18 @@
-import type from './type';
-import range from './range';
-import enumRule from './enum';
-import pattern from './pattern';
-import required from './required';
-import whitespace from './whitespace';
-export default {
-  type: type,
-  range: range,
-  pattern: pattern,
-  required: required,
-  whitespace: whitespace,
-  "enum": enumRule
-};
+import "../../../chunk-PKUHTIDK.js";
+import type from "./type";
+import range from "./range";
+import enumRule from "./enum";
+import pattern from "./pattern";
+import required from "./required";
+import whitespace from "./whitespace";
+var rules_default = {
+  type,
+  range,
+  pattern,
+  required,
+  whitespace,
+  enum: enumRule
+};
+export {
+  rules_default as default
+};

package/common/validate/rules/pattern.js

@@ -1,16 +1,20 @@
-import * as util from '../util';
-export default function (rule, checkValue, source, errors, options) {
+import "../../../chunk-PKUHTIDK.js";
+import * as util from "../util";
+function pattern_default(rule, checkValue, source, errors, options) {
   if (rule.pattern) {
     if (rule.pattern instanceof RegExp) {
       rule.pattern.lastIndex = 0;
       if (!rule.pattern.test(checkValue)) {
         errors.push(util.format(options.messages.pattern.mismatch, rule.fullField, checkValue, rule.pattern));
       }
-    } else if (typeof rule.pattern === 'string') {
-      var _pattern = new RegExp(rule.pattern);
+    } else if (typeof rule.pattern === "string") {
+      const _pattern = new RegExp(rule.pattern);
       if (!_pattern.test(checkValue)) {
         errors.push(util.format(options.messages.pattern.mismatch, rule.fullField, checkValue, rule.pattern));
       }
     }
   }
-}
+}
+export {
+  pattern_default as default
+};

package/common/validate/rules/range.js

@@ -1,38 +1,31 @@
-import * as util from '../util';
-import { isNumber } from '@opentiny/vue-renderless/common/type';
-import { getLength } from '@opentiny/vue-renderless/common/string';
-function getErro(_ref) {
-  var min = _ref.min,
-    max = _ref.max,
-    val = _ref.val,
-    key = _ref.key,
-    rule = _ref.rule,
-    errors = _ref.errors,
-    util = _ref.util,
-    options = _ref.options;
+import "../../../chunk-PKUHTIDK.js";
+import * as util from "../util";
+import { isNumber } from "@opentiny/vue-renderless/common/type";
+import { getLength } from "@opentiny/vue-renderless/common/string";
+function getErro({ min, max, val, key, rule, errors, util: util2, options }) {
   if (min && !max && val < rule.min) {
-    errors.push(util.format(options.messages[key].min, rule.fullField, rule.min));
+    errors.push(util2.format(options.messages[key].min, rule.fullField, rule.min));
   } else if (max && !min && val > rule.max) {
-    errors.push(util.format(options.messages[key].max, rule.fullField, rule.max));
+    errors.push(util2.format(options.messages[key].max, rule.fullField, rule.max));
   } else if (min && max && (val < rule.min || val > rule.max)) {
-    errors.push(util.format(options.messages[key].range, rule.fullField, rule.min, rule.max));
+    errors.push(util2.format(options.messages[key].range, rule.fullField, rule.min, rule.max));
   }
 }
-export default function (rule, checkValue, source, errors, options) {
-  var len = isNumber(rule.len);
-  var min = isNumber(rule.min);
-  var max = isNumber(rule.max);
-  var val = checkValue;
-  var key = null;
-  var num = isNumber(checkValue);
-  var str = typeof checkValue === 'string';
-  var arr = Array.isArray(checkValue);
+function range_default(rule, checkValue, source, errors, options) {
+  const len = isNumber(rule.len);
+  const min = isNumber(rule.min);
+  const max = isNumber(rule.max);
+  let val = checkValue;
+  let key = null;
+  const num = isNumber(checkValue);
+  const str = typeof checkValue === "string";
+  const arr = Array.isArray(checkValue);
   if (num) {
-    key = 'number';
+    key = "number";
   } else if (str) {
-    key = 'string';
+    key = "string";
   } else if (arr) {
-    key = 'array';
+    key = "array";
   }
   if (!key) {
     return false;
@@ -41,22 +34,16 @@ export default function (rule, checkValue, source, errors, options) {
     val = checkValue.length;
   }
   if (str) {
-    val = getLength(checkValue, 'string');
+    val = getLength(checkValue, "string");
   }
   if (len) {
     if (val !== rule.len) {
       errors.push(util.format(options.messages[key].len, rule.fullField, rule.len));
     }
   } else {
-    getErro({
-      min: min,
-      max: max,
-      val: val,
-      key: key,
-      rule: rule,
-      errors: errors,
-      util: util,
-      options: options
-    });
+    getErro({ min, max, val, key, rule, errors, util, options });
   }
-}
+}
+export {
+  range_default as default
+};

package/common/validate/rules/required.js

@@ -1,13 +1,11 @@
-import * as util from '../util';
-import { hasOwn } from '@opentiny/vue-renderless/common/type';
-export default function (_ref) {
-  var rule = _ref.rule,
-    checkValue = _ref.checkValue,
-    source = _ref.source,
-    errors = _ref.errors,
-    options = _ref.options,
-    type = _ref.type;
+import "../../../chunk-PKUHTIDK.js";
+import * as util from "../util";
+import { hasOwn } from "@opentiny/vue-renderless/common/type";
+function required_default({ rule, checkValue, source, errors, options, type }) {
   if (rule.required && (!hasOwn.call(source, rule.field) || util.isEmptyValue(checkValue, type || rule.type))) {
     errors.push(util.format(options.messages.required, rule.fullField));
   }
-}
+}
+export {
+  required_default as default
+};

package/common/validate/rules/type.js

@@ -1,32 +1,28 @@
-import _typeof from "@babel/runtime/helpers/typeof";
-import * as util from '../util';
-import required from './required';
-import { format } from '@opentiny/vue-renderless/common/date';
-import { isNullOrEmpty } from '@opentiny/vue-renderless/common/string';
-import { isNumber, isObject, isDate, typeOf } from '@opentiny/vue-renderless/common/type';
-var emailReg1 = '^(([^<>()\\[\\]\\\\.,;:\\s@"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@"]+)*)|(".+"))';
-var emailReg = new RegExp(emailReg1 + '@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,6}))$');
-var pattern = {
+import "../../../chunk-PKUHTIDK.js";
+import * as util from "../util";
+import required from "./required";
+import { format } from "@opentiny/vue-renderless/common/date";
+import { isNullOrEmpty } from "@opentiny/vue-renderless/common/string";
+import { isNumber, isObject, isDate, typeOf } from "@opentiny/vue-renderless/common/type";
+const emailReg1 = '^(([^<>()\\[\\]\\\\.,;:\\s@"]+(\\.[^<>()\\[\\]\\\\.,;:\\s@"]+)*)|(".+"))';
+const emailReg = new RegExp(emailReg1 + "@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,6}))$");
+const pattern = {
   acceptImg: /\.(png|jpe?g|gif)$/,
   acceptFile: /\.(doc?x|xls?x|ppt?x|txt)$/,
   email: emailReg,
   fileSize: /^\d+(\.\d+)?[KMGTPEZY]?B$/i,
   hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i,
-  speczh: /^[0-9a-zA-Z_\u4e00-\u9fa5]+$/,
+  speczh: /^[0-9a-zA-Z_\u4E00-\u9FA5]+$/,
   specialch: /^[0-9a-zA-Z_\-.]+$/,
   specialch2: /^[0-9a-zA-Z_-]+$/,
   url: /^([a-zA-Z]{3,}):\/\/([\w-]+\.)+[\w]+(\/[a-zA-Z- ./?%&=]*)?/i,
   version: /^\d+\.\d+(\.\d+)*$/
 };
-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);
-  },
+const types = {
+  integer: (value) => types.number(value) && parseInt(value, 10) === value,
+  float: (value) => types.number(value) && !types.integer(value),
   array: Array.isArray,
-  regexp: function regexp(value) {
+  regexp(value) {
     if (value instanceof RegExp) {
       return true;
     }
@@ -38,73 +34,65 @@ var types = {
   },
   date: isDate,
   number: isNumber,
-  object: function object(value) {
-    return isObject(value) && !types.array(value);
-  },
-  method: function method(value) {
-    return typeOf(value) === 'function';
-  },
-  email: function email(value) {
-    return isNullOrEmpty(value) || !!value.match(pattern.email) && value.length < 255;
-  },
-  url: function url(value) {
-    return isNullOrEmpty(value) || !!value.match(pattern.url);
-  },
-  hex: function hex(value) {
-    return isNullOrEmpty(value) || !!value.match(pattern.hex);
-  },
-  digits: function digits(value) {
-    return isNullOrEmpty(value) || /^\d+$/.test(value);
-  },
-  time: function time(value) {
-    return isNullOrEmpty(value) || /^((0)[0-9]|1[0-9]|20|21|22|23):([0-5][0-9])$/.test(value);
-  },
-  dateYM: function dateYM(value) {
-    return isNullOrEmpty(value) || format(value, 'yyyy-MM') === value;
-  },
-  dateYMD: function dateYMD(value) {
-    return isNullOrEmpty(value) || format(value, 'yyyy-MM-dd') === value;
-  },
-  dateTime: function dateTime(value) {
-    return isNullOrEmpty(value) || format(value, 'yyyy-MM-dd hh:mm') === value;
-  },
-  longDateTime: function longDateTime(value) {
-    return isNullOrEmpty(value) || format(value, 'yyyy-MM-dd hh:mm:ss') === value;
-  },
-  version: function version(value) {
-    return isNullOrEmpty(value) || !!value.match(pattern.version);
-  },
-  speczh: function speczh(value) {
-    return isNullOrEmpty(value) || !!value.match(pattern.speczh);
-  },
-  specialch: function specialch(value) {
-    return isNullOrEmpty(value) || !!value.match(pattern.specialch);
-  },
-  specialch2: function specialch2(value) {
-    return isNullOrEmpty(value) || !!value.match(pattern.specialch2);
-  },
-  acceptImg: function acceptImg(value) {
-    return isNullOrEmpty(value) || !!value.match(pattern.acceptImg);
-  },
-  acceptFile: function acceptFile(value) {
-    return isNullOrEmpty(value) || !!value.match(pattern.acceptFile);
-  },
-  fileSize: function fileSize(value) {
-    return isNullOrEmpty(value) || !!value.match(pattern.fileSize);
-  }
+  object: (value) => isObject(value) && !types.array(value),
+  method: (value) => typeOf(value) === "function",
+  email: (value) => isNullOrEmpty(value) || !!value.match(pattern.email) && value.length < 255,
+  url: (value) => isNullOrEmpty(value) || !!value.match(pattern.url),
+  hex: (value) => isNullOrEmpty(value) || !!value.match(pattern.hex),
+  digits: (value) => isNullOrEmpty(value) || /^\d+$/.test(value),
+  time: (value) => isNullOrEmpty(value) || /^((0)[0-9]|1[0-9]|20|21|22|23):([0-5][0-9])$/.test(value),
+  dateYM: (value) => isNullOrEmpty(value) || format(value, "yyyy-MM") === value,
+  dateYMD: (value) => isNullOrEmpty(value) || format(value, "yyyy-MM-dd") === value,
+  dateTime: (value) => isNullOrEmpty(value) || format(value, "yyyy-MM-dd hh:mm") === value,
+  longDateTime: (value) => isNullOrEmpty(value) || format(value, "yyyy-MM-dd hh:mm:ss") === value,
+  version: (value) => isNullOrEmpty(value) || !!value.match(pattern.version),
+  speczh: (value) => isNullOrEmpty(value) || !!value.match(pattern.speczh),
+  specialch: (value) => isNullOrEmpty(value) || !!value.match(pattern.specialch),
+  specialch2: (value) => isNullOrEmpty(value) || !!value.match(pattern.specialch2),
+  acceptImg: (value) => isNullOrEmpty(value) || !!value.match(pattern.acceptImg),
+  acceptFile: (value) => isNullOrEmpty(value) || !!value.match(pattern.acceptFile),
+  fileSize: (value) => isNullOrEmpty(value) || !!value.match(pattern.fileSize)
 };
-export default function (rule, value, source, errors, options) {
-  if (rule.required && value === undefined) {
+function type_default(rule, value, source, errors, options) {
+  if (rule.required && value === void 0) {
     required(rule, value, source, errors, options);
     return;
   }
-  var custom = ['array', 'acceptImg', 'acceptFile', 'date', 'digits', 'dateTime', 'dateYM', 'dateYMD', 'email', 'float', 'fileSize', 'hex', 'integer', 'longDateTime', 'method', 'number', 'object', 'regexp', 'speczh', 'specialch', 'specialch2', 'time', 'version', 'url'];
-  var ruleType = rule.type;
-  if (custom.indexOf(ruleType) > -1) {
+  const custom = [
+    "array",
+    "acceptImg",
+    "acceptFile",
+    "date",
+    "digits",
+    "dateTime",
+    "dateYM",
+    "dateYMD",
+    "email",
+    "float",
+    "fileSize",
+    "hex",
+    "integer",
+    "longDateTime",
+    "method",
+    "number",
+    "object",
+    "regexp",
+    "speczh",
+    "specialch",
+    "specialch2",
+    "time",
+    "version",
+    "url"
+  ];
+  const ruleType = rule.type;
+  if (custom.includes(ruleType)) {
     if (!types[ruleType](value)) {
       errors.push(util.format(options.messages.types[ruleType], rule.fullField, rule.type));
     }
-  } else if (ruleType && _typeof(value) !== rule.type) {
+  } else if (ruleType && typeof value !== rule.type) {
     errors.push(util.format(options.messages.types[ruleType], rule.fullField, rule.type));
   }
-}
+}
+export {
+  type_default as default
+};

package/common/validate/rules/whitespace.js

@@ -1,6 +1,10 @@
-import * as util from '../util';
-export default function (rule, checkValue, source, errors, options) {
-  if (/^\s+$/.test(checkValue) || checkValue === '') {
+import "../../../chunk-PKUHTIDK.js";
+import * as util from "../util";
+function whitespace_default(rule, checkValue, source, errors, options) {
+  if (/^\s+$/.test(checkValue) || checkValue === "") {
     errors.push(util.format(options.messages.whitespace, rule.fullField));
   }
-}
+}
+export {
+  whitespace_default as default
+};