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

package/common/validate/schema.js

@@ -1,83 +1,74 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _typeof from "@babel/runtime/helpers/typeof";
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-import { format, complementError, asyncMap, warning, deepMerge, convertFieldsError } from './util';
-import { hasOwn, isFunction } from '@opentiny/vue-renderless/common/type';
+import {
+  __spreadProps,
+  __spreadValues
+} from "../../chunk-PKUHTIDK.js";
+import { format, complementError, asyncMap, warning, deepMerge, convertFieldsError } from "./util";
+import { hasOwn, isFunction } from "@opentiny/vue-renderless/common/type";
 function Schema(descriptor, translate) {
-  Schema.getSystemMessage = function () {
-    return Schema.getDefaultMessage(translate);
-  };
+  Schema.getSystemMessage = () => Schema.getDefaultMessage(translate);
   Schema.messages = Schema.getSystemMessage(translate);
   Schema.systemMessages = Schema.messages;
   this.rules = null;
   this._messages = Schema.systemMessages;
   this.define(descriptor);
 }
-var getCompleteFn = function getCompleteFn(validCallback) {
-  return function (results) {
-    var idx;
-    var errors = [];
-    var fields = {};
-    function addValid(eror) {
-      if (Array.isArray(eror)) {
-        var _errors;
-        errors = (_errors = errors).concat.apply(_errors, _toConsumableArray(eror));
-      } else {
-        errors.push(eror);
-      }
-    }
-    for (idx = 0; idx < results.length; idx++) {
-      addValid(results[idx]);
-    }
-    if (errors.length) {
-      fields = convertFieldsError(errors);
+const getCompleteFn = (validCallback) => (results) => {
+  let idx;
+  let errors = [];
+  let fields = {};
+  function addValid(eror) {
+    if (Array.isArray(eror)) {
+      errors = errors.concat(...eror);
     } else {
-      errors = null;
-      fields = null;
+      errors.push(eror);
     }
-    validCallback(errors, fields);
-  };
+  }
+  for (idx = 0; idx < results.length; idx++) {
+    addValid(results[idx]);
+  }
+  if (errors.length) {
+    fields = convertFieldsError(errors);
+  } else {
+    errors = null;
+    fields = null;
+  }
+  validCallback(errors, fields);
 };
-var isDeep = function isDeep(rule, data) {
-  var deep = (rule.type === 'object' || rule.type === 'array') && (_typeof(rule.fields) === 'object' || _typeof(rule.defaultField) === 'object');
+const isDeep = (rule, data) => {
+  let deep = (rule.type === "object" || rule.type === "array") && (typeof rule.fields === "object" || typeof rule.defaultField === "object");
   deep = deep && (rule.required || !rule.required && data.value);
   return deep;
 };
-var getFieldsSchema = function getFieldsSchema(rule, data) {
-  var schema = {};
+const getFieldsSchema = (rule, data) => {
+  let schema = {};
   function addFullfield(key, item) {
-    return _objectSpread(_objectSpread({}, item), {}, {
-      fullField: "".concat(rule.fullField, ".").concat(key)
+    return __spreadProps(__spreadValues({}, item), {
+      fullField: `${rule.fullField}.${key}`
     });
   }
   if (rule.defaultField) {
-    for (var k in data.value) {
+    for (const k in data.value) {
       if (hasOwn.call(data.value, k)) {
         schema[k] = rule.defaultField;
       }
     }
   }
-  schema = _objectSpread(_objectSpread({}, schema), data.rule.fields);
-  for (var f in schema) {
+  schema = __spreadValues(__spreadValues({}, schema), data.rule.fields);
+  for (const f in schema) {
     if (hasOwn.call(schema, f)) {
-      var fieldSchema = Array.isArray(schema[f]) ? schema[f] : [schema[f]];
+      const fieldSchema = Array.isArray(schema[f]) ? schema[f] : [schema[f]];
       schema[f] = fieldSchema.map(addFullfield.bind(null, f));
     }
   }
   return schema;
 };
-var arrayed = function arrayed(failds) {
+const arrayed = (failds) => {
   if (!Array.isArray(failds)) {
     failds = [failds];
   }
   return failds;
 };
-var getRequiredErrorFeilds = function getRequiredErrorFeilds(_ref) {
-  var rule = _ref.rule,
-    failds = _ref.failds,
-    options = _ref.options;
+const getRequiredErrorFeilds = ({ rule, failds, options }) => {
   if (rule.message) {
     failds = [].concat(rule.message).map(complementError(rule));
   } else if (options.error) {
@@ -87,144 +78,112 @@ var getRequiredErrorFeilds = function getRequiredErrorFeilds(_ref) {
   }
   return failds;
 };
-var setDataRuleOptions = function setDataRuleOptions(_ref2) {
-  var data = _ref2.data,
-    options = _ref2.options;
+const setDataRuleOptions = ({ data, options }) => {
   if (data.rule.options) {
-    var messages = options.messages,
-      error = options.error;
-    Object.assign(data.rule.options, {
-      messages: messages,
-      error: error
-    });
+    let { messages, error } = options;
+    Object.assign(data.rule.options, { messages, error });
   }
 };
-var getValidateCallback = function getValidateCallback(_ref3) {
-  var failds = _ref3.failds,
-    doIt = _ref3.doIt;
-  return function (errs) {
-    var finalErrors = [];
-    if (failds && failds.length) {
-      finalErrors.push.apply(finalErrors, _toConsumableArray(failds));
-    }
-    if (errs && errs.length) {
-      finalErrors.push.apply(finalErrors, _toConsumableArray(errs));
-    }
-    doIt(finalErrors.length ? finalErrors : null);
-  };
+const getValidateCallback = ({ failds, doIt }) => (errs) => {
+  const finalErrors = [];
+  if (failds && failds.length) {
+    finalErrors.push(...failds);
+  }
+  if (errs && errs.length) {
+    finalErrors.push(...errs);
+  }
+  doIt(finalErrors.length ? finalErrors : null);
 };
-var asyncCallback = function asyncCallback(options, rule, errorFields, doIt, data) {
-  return function () {
-    var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    var failds = e;
-    var deep = isDeep(rule, data);
-    failds = arrayed(failds);
-    if (!options.suppressWarning && failds.length) {
-      Schema.warning('async-validator:', failds);
-    }
-    if (failds.length && rule.message) {
-      failds = [].concat(rule.message);
-    }
-    failds = failds.map(complementError(rule));
-    if (options.first && failds.length) {
-      errorFields[rule.field] = 1;
+const asyncCallback = (options, rule, errorFields, doIt, data) => (e = []) => {
+  let failds = e;
+  const deep = isDeep(rule, data);
+  failds = arrayed(failds);
+  if (!options.suppressWarning && failds.length) {
+    Schema.warning("async-validator:", failds);
+  }
+  if (failds.length && rule.message) {
+    failds = [].concat(rule.message);
+  }
+  failds = failds.map(complementError(rule));
+  if (options.first && failds.length) {
+    errorFields[rule.field] = 1;
+    return doIt(failds);
+  }
+  if (deep) {
+    if (rule.required && !data.value) {
+      failds = getRequiredErrorFeilds({ rule, failds, options });
       return doIt(failds);
     }
-    if (deep) {
-      if (rule.required && !data.value) {
-        failds = getRequiredErrorFeilds({
-          rule: rule,
-          failds: failds,
-          options: options
-        });
-        return doIt(failds);
-      }
-      var schema = new Schema(getFieldsSchema(rule, data));
-      schema.messages(options.messages);
-      setDataRuleOptions({
-        data: data,
-        options: options
-      });
-      schema.validate(data.value, data.rule.options || options, getValidateCallback({
-        failds: failds,
-        doIt: doIt
-      }));
-    } else {
-      doIt(failds);
-    }
-  };
+    const schema = new Schema(getFieldsSchema(rule, data));
+    schema.messages(options.messages);
+    setDataRuleOptions({ data, options });
+    schema.validate(data.value, data.rule.options || options, getValidateCallback({ failds, doIt }));
+  } else {
+    doIt(failds);
+  }
 };
 Schema.prototype = {
-  messages: function messages(_messages) {
-    if (_messages) {
-      this._messages = deepMerge(Schema.getSystemMessage(), _messages);
+  messages(messages) {
+    if (messages) {
+      this._messages = deepMerge(Schema.getSystemMessage(), messages);
     }
     return this._messages;
   },
-  define: function define(rules) {
-    var _this = this;
+  define(rules) {
     if (!rules) {
-      throw new Error('Cannot configure a schema with no rules');
+      throw new Error("Cannot configure a schema with no rules");
     }
-    if (Array.isArray(rules) || _typeof(rules) !== 'object') {
-      throw new Error('Rules must be an object');
+    if (Array.isArray(rules) || typeof rules !== "object") {
+      throw new TypeError("Rules must be an object");
     }
     this.rules = {};
-    var rule;
-    Object.keys(rules).forEach(function (key) {
+    let rule;
+    Object.keys(rules).forEach((key) => {
       if (hasOwn.call(rules, key)) {
         rule = rules[key];
-        _this.rules[key] = Array.isArray(rule) ? rule : [rule];
+        this.rules[key] = Array.isArray(rule) ? rule : [rule];
       }
     });
   },
-  getSeries: function getSeries(options, source, source_) {
-    var _this2 = this;
-    var arr;
-    var value;
-    var series = {};
-    var keys = options.keys || Object.keys(this.rules);
-    keys.forEach(function (key) {
-      arr = _this2.rules[key];
+  getSeries(options, source, source_) {
+    let arr;
+    let value;
+    const series = {};
+    const keys = options.keys || Object.keys(this.rules);
+    keys.forEach((key) => {
+      arr = this.rules[key];
       value = source[key];
-      arr.forEach(function (r) {
-        var rule = r;
-        if (typeof rule.transform === 'function') {
+      arr.forEach((r) => {
+        let rule = r;
+        if (typeof rule.transform === "function") {
           if (source === source_) {
-            source = _objectSpread({}, source);
+            source = __spreadValues({}, source);
           }
           source[key] = rule.transform(value);
           value = source[key];
         }
-        if (typeof rule === 'function') {
-          rule = {
-            validator: rule
-          };
+        if (typeof rule === "function") {
+          rule = { validator: rule };
         } else {
-          rule = _objectSpread({}, rule);
+          rule = __spreadValues({}, rule);
         }
-        rule.validator = _this2.getValidationMethod(rule);
+        rule.validator = this.getValidationMethod(rule);
         rule.field = key;
         rule.fullField = rule.fullField || key;
-        rule.type = _this2.getType(rule);
+        rule.type = this.getType(rule);
         options.custom && Object.assign(rule, options.custom);
         if (!rule.validator) {
           return;
         }
         series[key] = series[key] || [];
-        series[key].push({
-          rule: rule,
-          value: value,
-          source: source,
-          field: key
-        });
+        series[key].push({ rule, value, source, field: key });
       });
     });
     return series;
   },
-  mergeMessage: function mergeMessage(options) {
+  mergeMessage(options) {
     if (options.messages) {
-      var messages = this.messages();
+      let messages = this.messages();
       if (messages === Schema.systemMessages) {
         messages = Schema.getSystemMessage();
       }
@@ -234,15 +193,11 @@ Schema.prototype = {
       options.messages = this.messages();
     }
   },
-  validate: function validate(source_) {
-    var o = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var oc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {
-      return undefined;
-    };
-    var source = source_;
-    var options = o;
-    var validCallback = oc;
-    if (typeof options === 'function') {
+  validate(source_, o = {}, oc = () => void 0) {
+    let source = source_;
+    let options = o;
+    let validCallback = oc;
+    if (typeof options === "function") {
       validCallback = options;
       options = {};
     }
@@ -250,66 +205,70 @@ Schema.prototype = {
       validCallback && validCallback();
       return Promise.resolve();
     }
-    var complete = getCompleteFn(validCallback);
+    const complete = getCompleteFn(validCallback);
     this.mergeMessage(options);
-    var seriesData = this.getSeries(options, source, source_);
-    var errorFields = {};
-    return asyncMap(seriesData, options, function (data, doIt) {
-      var rule = data.rule;
-      var validHandler = asyncCallback(options, rule, errorFields, doIt, data);
-      var validResult;
-      if (rule.asyncValidator) {
-        validResult = rule.asyncValidator(rule, data.value, validHandler, data.source, options);
-      } else if (rule.validator) {
-        validResult = rule.validator(rule, data.value, validHandler, data.source, options);
-        if (validResult === true) {
-          validHandler();
-        } else if (validResult === false) {
-          validHandler(rule.message || "".concat(rule.field, " fails"));
-        } else if (Array.isArray(validResult)) {
-          validHandler(validResult);
-        } else if (validResult instanceof Error) {
-          validHandler(validResult.message);
+    const seriesData = this.getSeries(options, source, source_);
+    const errorFields = {};
+    return asyncMap(
+      seriesData,
+      options,
+      (data, doIt) => {
+        const rule = data.rule;
+        const validHandler = asyncCallback(options, rule, errorFields, doIt, data);
+        let validResult;
+        if (rule.asyncValidator) {
+          validResult = rule.asyncValidator(rule, data.value, validHandler, data.source, options);
+        } else if (rule.validator) {
+          validResult = rule.validator(rule, data.value, validHandler, data.source, options);
+          if (validResult === true) {
+            validHandler();
+          } else if (validResult === false) {
+            validHandler(rule.message || `${rule.field} fails`);
+          } else if (Array.isArray(validResult)) {
+            validHandler(validResult);
+          } else if (validResult instanceof Error) {
+            validHandler(validResult.message);
+          }
         }
+        if (validResult && validResult.then) {
+          validResult.then(
+            () => validHandler(),
+            (e) => validHandler(e)
+          );
+        }
+      },
+      (results) => {
+        complete(results);
       }
-      if (validResult && validResult.then) {
-        validResult.then(function () {
-          return validHandler();
-        }, function (e) {
-          return validHandler(e);
-        });
-      }
-    }, function (results) {
-      complete(results);
-    });
+    );
   },
-  getValidationMethod: function getValidationMethod(rule) {
+  getValidationMethod(rule) {
     if (isFunction(rule.validator)) {
       return rule.validator;
     }
-    var ruleKeys = Object.keys(rule);
-    var messageIndex = ruleKeys.indexOf('message');
+    const ruleKeys = Object.keys(rule);
+    const messageIndex = ruleKeys.indexOf("message");
     if (messageIndex > -1) {
       ruleKeys.splice(messageIndex, 1);
     }
-    if (ruleKeys.length === 1 && ruleKeys[0] === 'required') {
+    if (ruleKeys.length === 1 && ruleKeys[0] === "required") {
       return Schema.validators.required;
     }
     return Schema.validators[this.getType(rule)] || false;
   },
-  getType: function getType(rule) {
-    if (rule.type === undefined && rule.pattern instanceof RegExp) {
-      rule.type = 'pattern';
+  getType(rule) {
+    if (rule.type === void 0 && rule.pattern instanceof RegExp) {
+      rule.type = "pattern";
     }
-    if (typeof rule.validator !== 'function' && rule.type && !hasOwn.call(Schema.validators, rule.type)) {
-      throw new Error(format('Unknown rule type %s', rule.type));
+    if (typeof rule.validator !== "function" && rule.type && !hasOwn.call(Schema.validators, rule.type)) {
+      throw new Error(format("Unknown rule type %s", rule.type));
     }
-    return rule.type || 'string';
+    return rule.type || "string";
   }
 };
-Schema.register = function (type, validator) {
-  if (typeof validator !== 'function') {
-    throw new Error('Cannot register a validator by type, validator is not a function');
+Schema.register = (type, validator) => {
+  if (typeof validator !== "function") {
+    throw new TypeError("Cannot register a validator by type, validator is not a function");
   }
   Schema.validators[type] = validator;
 };
@@ -317,7 +276,8 @@ Schema.validators = {};
 Schema.warning = warning;
 Schema.messages = {};
 Schema.systemMessages = {};
-Schema.getDefaultMessage = function () {
-  return undefined;
+Schema.getDefaultMessage = () => void 0;
+var schema_default = Schema;
+export {
+  schema_default as default
 };
-export default Schema;