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

package/common/validate/util.js

@@ -1,52 +1,46 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _typeof from "@babel/runtime/helpers/typeof";
-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 { hasOwn, isNull } from '@opentiny/vue-renderless/common/type';
-var formatRegExp = /%[sdj%]/g;
-export var warning = function warning() {
-  return undefined;
-};
-export function convertFieldsError(errors) {
+import {
+  __spreadValues
+} from "../../chunk-PKUHTIDK.js";
+import { hasOwn, isNull } from "@opentiny/vue-renderless/common/type";
+const formatRegExp = /%[sdj%]/g;
+let warning = () => void 0;
+function convertFieldsError(errors) {
   if (!errors || !errors.length) {
     return null;
   }
-  var fields = {};
-  errors.forEach(function (error) {
-    var field = error.field;
+  const fields = {};
+  errors.forEach((error) => {
+    const field = error.field;
     fields[field] = fields[field] || [];
     fields[field].push(error);
   });
   return fields;
 }
-export function format() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-  var i = 1;
-  var checkData = args[0];
-  var len = args.length;
-  if (typeof checkData === 'function') {
+function format(...args) {
+  let i = 1;
+  const checkData = args[0];
+  const len = args.length;
+  if (typeof checkData === "function") {
     return checkData.apply(null, args.slice(1));
   }
-  if (typeof checkData === 'string') {
-    var str = String(checkData).replace(formatRegExp, function (matchChar) {
-      if (matchChar === '%%') {
-        return '%';
+  if (typeof checkData === "string") {
+    let str = String(checkData).replace(formatRegExp, (matchChar) => {
+      if (matchChar === "%%") {
+        return "%";
       }
       if (i >= len) {
         return matchChar;
       }
       switch (matchChar) {
-        case '%j':
+        case "%j":
           try {
             return JSON.stringify(args[i++]);
           } catch (e) {
-            return '[Circular]';
+            return "[Circular]";
           }
-        case '%d':
+        case "%d":
           return Number(args[i++]);
-        case '%s':
+        case "%s":
           return String(args[i++]);
         default:
           return matchChar;
@@ -57,27 +51,46 @@ export function format() {
   return checkData;
 }
 function isNativeStringType(type) {
-  return ~['string', 'url', 'hex', 'email', 'pattern', 'digits', 'time', 'dateYMD', 'longDateTime', 'dateTime', 'dateYM', 'version', 'speczh', 'specialch', 'specialch2', 'acceptImg', 'acceptFile', 'fileSize'].indexOf(type);
+  return ~[
+    "string",
+    "url",
+    "hex",
+    "email",
+    "pattern",
+    "digits",
+    "time",
+    "dateYMD",
+    "longDateTime",
+    "dateTime",
+    "dateYM",
+    "version",
+    "speczh",
+    "specialch",
+    "specialch2",
+    "acceptImg",
+    "acceptFile",
+    "fileSize"
+  ].indexOf(type);
 }
-export function isEmptyValue(data, dataType) {
+function isEmptyValue(data, dataType) {
   if (isNull(data)) {
     return true;
   }
-  if (dataType === 'array' && Array.isArray(data) && !data.length) {
+  if (dataType === "array" && Array.isArray(data) && !data.length) {
     return true;
   }
-  if (isNativeStringType(dataType) && typeof data === 'string' && !data) {
+  if (isNativeStringType(dataType) && typeof data === "string" && !data) {
     return true;
   }
   return false;
 }
-export function isEmptyObject(data) {
+function isEmptyObject(data) {
   return Object.keys(data).length === 0;
 }
 function asyncParallelArray(arrData, func, callback) {
-  var count = 0;
-  var results = [];
-  var arrLength = arrData.length;
+  let count = 0;
+  const results = [];
+  const arrLength = arrData.length;
   function checkCount(errors) {
     results.push.apply(results, errors);
     count++;
@@ -85,19 +98,19 @@ function asyncParallelArray(arrData, func, callback) {
       callback(results);
     }
   }
-  arrData.forEach(function (rule) {
+  arrData.forEach((rule) => {
     func(rule, checkCount);
   });
 }
 function asyncSerialArray(arr, fn, cb) {
-  var idx = 0;
-  var arrLength = arr.length;
+  let idx = 0;
+  const arrLength = arr.length;
   function checkNext(errorList) {
     if (errorList && errorList.length) {
       cb(errorList);
       return;
     }
-    var original = idx;
+    const original = idx;
     idx = idx + 1;
     if (original < arrLength) {
       fn(arr[original], checkNext);
@@ -108,54 +121,46 @@ function asyncSerialArray(arr, fn, cb) {
   checkNext([]);
 }
 function flattenObjArr(objArr) {
-  var result = [];
-  Object.keys(objArr).forEach(function (item) {
+  const result = [];
+  Object.keys(objArr).forEach((item) => {
     result.push.apply(result, objArr[item]);
   });
   return result;
 }
-export function asyncMap(objArray, option, func, callback) {
+function asyncMap(objArray, option, func, callback) {
   if (option.first) {
-    var _pending = new Promise(function (resolve, reject) {
-      var errorFn = reject;
-      var next = function next(errors) {
+    const pending2 = new Promise((resolve, reject) => {
+      const errorFn = reject;
+      const next = (errors) => {
         callback(errors);
-        return errors.length ? errorFn({
-          errors: errors,
-          fields: convertFieldsError(errors)
-        }) : resolve();
+        return errors.length ? errorFn({ errors, fields: convertFieldsError(errors) }) : resolve();
       };
-      var flattenArr = flattenObjArr(objArray);
+      const flattenArr = flattenObjArr(objArray);
       asyncSerialArray(flattenArr, func, next);
     });
-    _pending["catch"](function (error) {
-      return error;
-    });
-    return _pending;
+    pending2.catch((error) => error);
+    return pending2;
   }
-  var firstFields = option.firstFields || [];
+  let firstFields = option.firstFields || [];
   if (firstFields === true) {
     firstFields = Object.keys(objArray);
   }
-  var total = 0;
-  var objArrayKeys = Object.keys(objArray);
-  var objArrLength = objArrayKeys.length;
-  var results = [];
-  var pending = new Promise(function (resolve, reject) {
-    var errorFn = reject;
-    var next = function next(errors) {
+  let total = 0;
+  const objArrayKeys = Object.keys(objArray);
+  const objArrLength = objArrayKeys.length;
+  const results = [];
+  const pending = new Promise((resolve, reject) => {
+    const errorFn = reject;
+    const next = (errors) => {
       results.push.apply(results, errors);
       total++;
       if (total === objArrLength) {
         callback(results);
-        return results.length ? errorFn({
-          errors: results,
-          fields: convertFieldsError(results)
-        }) : resolve();
+        return results.length ? errorFn({ errors: results, fields: convertFieldsError(results) }) : resolve();
       }
     };
-    objArrayKeys.forEach(function (key) {
-      var arr = objArray[key];
+    objArrayKeys.forEach((key) => {
+      const arr = objArray[key];
       if (~firstFields.indexOf(key)) {
         asyncSerialArray(arr, func, next);
       } else {
@@ -163,36 +168,44 @@ export function asyncMap(objArray, option, func, callback) {
       }
     });
   });
-  pending["catch"](function (e) {
-    return e;
-  });
+  pending.catch((e) => e);
   return pending;
 }
-export function complementError(rule) {
-  return function (onError) {
+function complementError(rule) {
+  return (onError) => {
     if (onError && onError.message) {
       onError.field = onError.field || rule.fullField;
       return onError;
     }
     return {
-      message: typeof onError === 'function' ? onError() : onError,
+      message: typeof onError === "function" ? onError() : onError,
       field: onError.field || rule.fullField
     };
   };
 }
-export function deepMerge(target, sources) {
+function deepMerge(target, sources) {
   if (!sources) {
     return target;
   }
-  for (var source in sources) {
+  for (const source in sources) {
     if (hasOwn.call(sources, source)) {
-      var value = sources[source];
-      if (_typeof(value) === 'object' && _typeof(target[source]) === 'object') {
-        target[source] = _objectSpread(_objectSpread({}, target[source]), value);
+      const value = sources[source];
+      if (typeof value === "object" && typeof target[source] === "object") {
+        target[source] = __spreadValues(__spreadValues({}, target[source]), value);
       } else {
         target[source] = value;
       }
     }
   }
   return target;
-}
+}
+export {
+  asyncMap,
+  complementError,
+  convertFieldsError,
+  deepMerge,
+  format,
+  isEmptyObject,
+  isEmptyValue,
+  warning
+};

package/common/validate/validations/array.js

@@ -1,25 +1,22 @@
-import rules from '../rules/index';
-import { isEmptyValue } from '../util';
-import { hasOwn } from '@opentiny/vue-renderless/common/type';
-export default function (rule, checkValue, callback, source, options) {
-  var errors = [];
-  var validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
+import "../../../chunk-PKUHTIDK.js";
+import rules from "../rules/index";
+import { isEmptyValue } from "../util";
+import { hasOwn } from "@opentiny/vue-renderless/common/type";
+function array_default(rule, checkValue, callback, source, options) {
+  const errors = [];
+  const validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
   if (validate) {
-    if (isEmptyValue(checkValue, 'array') && !rule.required) {
+    if (isEmptyValue(checkValue, "array") && !rule.required) {
       return callback();
     }
-    rules.required({
-      rule: rule,
-      checkValue: checkValue,
-      source: source,
-      errors: errors,
-      options: options,
-      type: 'array'
-    });
-    if (!isEmptyValue(checkValue, 'array')) {
+    rules.required({ rule, checkValue, source, errors, options, type: "array" });
+    if (!isEmptyValue(checkValue, "array")) {
       rules.type(rule, checkValue, source, errors, options);
       rules.range(rule, checkValue, source, errors, options);
     }
   }
   callback(errors);
-}
+}
+export {
+  array_default as default
+};

package/common/validate/validations/date.js

@@ -1,35 +1,31 @@
-import rules from '../rules/index';
-import { isEmptyValue } from '../util';
-import { hasOwn } from '@opentiny/vue-renderless/common/type';
-export default function (rule, checkValue, callback, source, options) {
-  var errors = [];
-  var validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
-  var isValidDateStr = function isValidDateStr(value) {
-    return value && typeof value === 'string' && new Date(value).toString() !== 'Invalid Date';
-  };
+import "../../../chunk-PKUHTIDK.js";
+import rules from "../rules/index";
+import { isEmptyValue } from "../util";
+import { hasOwn } from "@opentiny/vue-renderless/common/type";
+function date_default(rule, checkValue, callback, source, options) {
+  const errors = [];
+  const validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
+  const isValidDateStr = (value) => value && typeof value === "string" && new Date(value).toString() !== "Invalid Date";
   if (validate) {
     if (isEmptyValue(checkValue) && !rule.required) {
       return callback();
     }
-    rules.required({
-      rule: rule,
-      checkValue: checkValue,
-      source: source,
-      errors: errors,
-      options: options
-    });
+    rules.required({ rule, checkValue, source, errors, options });
     if (!isEmptyValue(checkValue)) {
-      var dateObject;
-      if (typeof checkValue === 'number' || isValidDateStr(checkValue)) {
+      let dateObject;
+      if (typeof checkValue === "number" || isValidDateStr(checkValue)) {
         dateObject = new Date(checkValue);
       } else {
         dateObject = checkValue;
       }
       rules.type(rule, dateObject, source, errors, options);
-      if (dateObject && typeof dateObject.getTime === 'function') {
+      if (dateObject && typeof dateObject.getTime === "function") {
         rules.range(rule, dateObject.getTime(), source, errors, options);
       }
     }
   }
   callback(errors);
-}
+}
+export {
+  date_default as default
+};

package/common/validate/validations/enum.js

@@ -1,24 +1,22 @@
-import rules from '../rules/index';
-import { isEmptyValue } from '../util';
-import { hasOwn } from '@opentiny/vue-renderless/common/type';
-var ENUM = 'enum';
-export default function (rule, checkValue, callback, source, options) {
-  var errors = [];
-  var validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
+import "../../../chunk-PKUHTIDK.js";
+import rules from "../rules/index";
+import { isEmptyValue } from "../util";
+import { hasOwn } from "@opentiny/vue-renderless/common/type";
+const ENUM = "enum";
+function enum_default(rule, checkValue, callback, source, options) {
+  const errors = [];
+  const validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
   if (validate) {
     if (isEmptyValue(checkValue) && !rule.required) {
       return callback();
     }
-    rules.required({
-      rule: rule,
-      checkValue: checkValue,
-      source: source,
-      errors: errors,
-      options: options
-    });
-    if (checkValue !== undefined) {
+    rules.required({ rule, checkValue, source, errors, options });
+    if (checkValue !== void 0) {
       rules[ENUM](rule, checkValue, source, errors, options);
     }
   }
   callback(errors);
-}
+}
+export {
+  enum_default as default
+};

package/common/validate/validations/float.js

@@ -1,24 +1,22 @@
-import rules from '../rules/index';
-import { isEmptyValue } from '../util';
-import { hasOwn } from '@opentiny/vue-renderless/common/type';
-export default function (rule, checkValue, cb, source, options) {
-  var errors = [];
-  var validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
+import "../../../chunk-PKUHTIDK.js";
+import rules from "../rules/index";
+import { isEmptyValue } from "../util";
+import { hasOwn } from "@opentiny/vue-renderless/common/type";
+function float_default(rule, checkValue, cb, source, options) {
+  const errors = [];
+  const validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
   if (validate) {
     if (isEmptyValue(checkValue) && !rule.required) {
       return cb();
     }
-    rules.required({
-      rule: rule,
-      checkValue: checkValue,
-      source: source,
-      errors: errors,
-      options: options
-    });
-    if (checkValue !== undefined) {
+    rules.required({ rule, checkValue, source, errors, options });
+    if (checkValue !== void 0) {
       rules.type(rule, checkValue, source, errors, options);
       rules.range(rule, checkValue, source, errors, options);
     }
   }
   cb(errors);
-}
+}
+export {
+  float_default as default
+};

package/common/validate/validations/index.js

@@ -1,24 +1,25 @@
-import date from './date';
-import type from './type';
-import _float from './float';
-import array from './array';
-import string from './string';
-import method from './method';
-import number from './number';
-import integer from './integer';
-import pattern from './pattern';
-import required from './required';
-import enumValidator from './enum';
-export default {
-  date: date,
-  "float": _float,
-  array: array,
-  string: string,
-  method: method,
-  number: number,
-  integer: integer,
-  pattern: pattern,
-  required: required,
+import "../../../chunk-PKUHTIDK.js";
+import date from "./date";
+import type from "./type";
+import float from "./float";
+import array from "./array";
+import string from "./string";
+import method from "./method";
+import number from "./number";
+import integer from "./integer";
+import pattern from "./pattern";
+import required from "./required";
+import enumValidator from "./enum";
+var validations_default = {
+  date,
+  float,
+  array,
+  string,
+  method,
+  number,
+  integer,
+  pattern,
+  required,
   hex: type,
   url: type,
   time: type,
@@ -33,10 +34,13 @@ export default {
   object: method,
   dateTime: type,
   specialch: type,
-  "boolean": method,
+  boolean: method,
   acceptImg: type,
   specialch2: type,
   acceptFile: type,
   longDateTime: type,
-  "enum": enumValidator
-};
+  enum: enumValidator
+};
+export {
+  validations_default as default
+};

package/common/validate/validations/integer.js

@@ -1,24 +1,22 @@
-import rules from '../rules/index';
-import { isEmptyValue } from '../util';
-import { hasOwn } from '@opentiny/vue-renderless/common/type';
-export default function (rule, checkValue, callback, source, options) {
-  var errors = [];
-  var validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
+import "../../../chunk-PKUHTIDK.js";
+import rules from "../rules/index";
+import { isEmptyValue } from "../util";
+import { hasOwn } from "@opentiny/vue-renderless/common/type";
+function integer_default(rule, checkValue, callback, source, options) {
+  const errors = [];
+  const validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
   if (validate) {
     if (isEmptyValue(checkValue) && !rule.required) {
       return callback();
     }
-    rules.required({
-      rule: rule,
-      checkValue: checkValue,
-      source: source,
-      errors: errors,
-      options: options
-    });
-    if (undefined !== checkValue) {
+    rules.required({ rule, checkValue, source, errors, options });
+    if (void 0 !== checkValue) {
       rules.type(rule, checkValue, source, errors, options);
       rules.range(rule, checkValue, source, errors, options);
     }
   }
   callback(errors);
-}
+}
+export {
+  integer_default as default
+};

package/common/validate/validations/method.js

@@ -1,23 +1,21 @@
-import rules from '../rules/index';
-import { isEmptyValue } from '../util';
-import { hasOwn } from '@opentiny/vue-renderless/common/type';
-export default function (rule, checkValue, callback, source, options) {
-  var validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
-  var errors = [];
+import "../../../chunk-PKUHTIDK.js";
+import rules from "../rules/index";
+import { isEmptyValue } from "../util";
+import { hasOwn } from "@opentiny/vue-renderless/common/type";
+function method_default(rule, checkValue, callback, source, options) {
+  const validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
+  const errors = [];
   if (validate) {
     if (!rule.required && isEmptyValue(checkValue)) {
       return callback();
     }
-    rules.required({
-      rule: rule,
-      checkValue: checkValue,
-      source: source,
-      errors: errors,
-      options: options
-    });
-    if (undefined !== checkValue) {
+    rules.required({ rule, checkValue, source, errors, options });
+    if (void 0 !== checkValue) {
       rules.type(rule, checkValue, source, errors, options);
     }
   }
   callback(errors);
-}
+}
+export {
+  method_default as default
+};

package/common/validate/validations/number.js

@@ -1,27 +1,25 @@
-import rules from '../rules/index';
-import { isEmptyValue } from '../util';
-import { hasOwn } from '@opentiny/vue-renderless/common/type';
-export default function (rule, checkValue, callback, source, options) {
-  var errors = [];
-  var validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
+import "../../../chunk-PKUHTIDK.js";
+import rules from "../rules/index";
+import { isEmptyValue } from "../util";
+import { hasOwn } from "@opentiny/vue-renderless/common/type";
+function number_default(rule, checkValue, callback, source, options) {
+  const errors = [];
+  const validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
   if (validate) {
-    if (checkValue === '') {
-      checkValue = undefined;
+    if (checkValue === "") {
+      checkValue = void 0;
     }
     if (!rule.required && isEmptyValue(checkValue)) {
       return callback();
     }
-    rules.required({
-      rule: rule,
-      checkValue: checkValue,
-      source: source,
-      errors: errors,
-      options: options
-    });
-    if (checkValue !== undefined) {
+    rules.required({ rule, checkValue, source, errors, options });
+    if (checkValue !== void 0) {
       rules.type(rule, checkValue, source, errors, options);
       rules.range(rule, checkValue, source, errors, options);
     }
   }
   callback(errors);
-}
+}
+export {
+  number_default as default
+};