@opentiny/vue-renderless 3.1.0-alpha.0

package/common/string.js

@@ -0,0 +1,446 @@
+import { isPlainObject, isNumber, isNumeric, isNull } from '@opentiny/vue-renderless/common/type';
+import { getObj, toJsonStr } from '@opentiny/vue-renderless/common/object';
+import { toFixed } from '@opentiny/vue-renderless/common/decimal';
+import { nanoid } from '@opentiny/vue-renderless/common/xss.js';
+export var formatTypes = {
+  text: 'text',
+  url: 'url',
+  html: 'html',
+  tmpl: 'tmpl'
+};
+export var escapeChars = {
+  '&': '&',
+  '<': '&#60;',
+  '>': '&#62;',
+  '"': '&#34;',
+  "'": '&#x27;',
+  '[': '&#91;',
+  ']': '&#93;'
+};
+export var isNullOrEmpty = function isNullOrEmpty(value) {
+  return value === null || value === undefined || typeof value === 'string' && value.trim().length === 0;
+};
+function cached(fn) {
+  var cache = Object.create(null);
+  return function cachedFn(str) {
+    var hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+}
+var camelizeRE = /-(\w)/g;
+export var camelize = cached(function (str) {
+  return str.replace(camelizeRE, function (_, c) {
+    return c ? c.toUpperCase() : '';
+  });
+});
+export var capitalize = cached(function (str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+var hyphenateRE = /\B([A-Z])/g;
+export var hyphenate = cached(function (str) {
+  return str.replace(hyphenateRE, '-$1').toLowerCase();
+});
+export var toJson = function toJson(string) {
+  try {
+    return JSON.parse(string);
+  } catch (e) {
+    return undefined;
+  }
+};
+function getLengthInUtf16(string) {
+  var len = string.length;
+  var count = 0;
+  for (var i = 0; i < len; i++) {
+    var charCode = string.charCodeAt(i);
+    if (charCode <= 0xffff) {
+      count += 2;
+    } else {
+      count += 4;
+    }
+  }
+  return count;
+}
+function getLengthInUtf8(string) {
+  var len = string.length;
+  var count = 0;
+  for (var i = 0; i < len; i++) {
+    var charCode = string.charCodeAt(i);
+    if (charCode <= 0x007f) {
+      count += 1;
+    } else if (charCode <= 0x07ff) {
+      count += 2;
+    } else if (charCode <= 0xffff) {
+      count += 3;
+    } else {
+      count += 4;
+    }
+  }
+  return count;
+}
+function getLengthDefault(string) {
+  var len = string.length;
+  var count = 0;
+  for (var i = 0; i < len; i++) {
+    count++;
+    if (string.charCodeAt(i) >> 8) {
+      count++;
+    }
+  }
+  return count;
+}
+export var getLength = function getLength(string, regular) {
+  if (!string || typeof string !== 'string') {
+    return 0;
+  }
+  var count = 0;
+  if (typeof regular === 'string') {
+    regular = regular.toLowerCase();
+    if (regular === 'utf-16' || regular === 'utf16') {
+      count = getLengthInUtf16(string);
+    } else if (regular === 'utf-8' || regular === 'utf8') {
+      count = getLengthInUtf8(string);
+    } else {
+      count = string.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, '_').length;
+    }
+  } else if (typeof regular === 'function') {
+    return regular(string);
+  } else {
+    count = getLengthDefault(string);
+  }
+  return count;
+};
+export var fillChar = function fillChar(string, length, append) {
+  var chr = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '0';
+  if (typeof string === 'string' && typeof chr === 'string' && isNumber(length)) {
+    var len = string.length - length;
+    if (len > 0) {
+      return append ? string.substr(0, length) : string.substr(len, length);
+    } else {
+      var appendStr = [];
+      len = Math.abs(len) / chr.length;
+      for (; len > 0; len--) {
+        appendStr.push(chr);
+      }
+      var s = appendStr.join('');
+      return append ? string + s : s + string;
+    }
+  }
+};
+export var random = nanoid.random;
+export var guid = function guid() {
+  var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  var length = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 8;
+  return prefix + random().toString().substr(2, length);
+};
+export var escapeHtml = function escapeHtml(string, isReplaceSpace) {
+  if (!string || typeof string !== 'string') {
+    return string;
+  }
+  string = string.replace(/[&<>"']/g, function (chr) {
+    return escapeChars[chr];
+  });
+  return isReplaceSpace ? string.replace(/\s/g, '&#160;') : string;
+};
+export var escape = function escape(string, escapeType, isReplaceSpace) {
+  if (!string || typeof string !== 'string') {
+    return string;
+  }
+  if (typeof escapeType === 'boolean') {
+    isReplaceSpace = !!escapeType;
+  }
+  if (escapeType === 'uri') {
+    return encodeURIComponent(string);
+  } else if (escapeType === 'html') {
+    return escapeHtml(string, isReplaceSpace);
+  } else if (escapeType === 'prop') {
+    string = escapeHtml(string, isReplaceSpace);
+    return string.replace(/[[\]]/g, function (chr) {
+      return escapeChars[chr];
+    });
+  }
+  string = string.replace(/[<>"]/g, function (chr) {
+    return escapeChars[chr];
+  });
+  return isReplaceSpace ? string.replace(/\s/g, '&#160;') : string;
+};
+var getFormat = function getFormat(_ref) {
+  var sign = _ref.sign,
+    format = _ref.format,
+    hasSign = _ref.hasSign;
+  switch (sign) {
+    case '#':
+      format = formatTypes.text;
+      break;
+    case '@':
+      format = formatTypes.url;
+      break;
+    case '$':
+      format = formatTypes.html;
+      break;
+    case '%':
+      format = formatTypes.tmpl;
+      break;
+    default:
+      hasSign = false;
+      break;
+  }
+  return {
+    format: format,
+    hasSign: hasSign
+  };
+};
+export var fieldFormat = function fieldFormat(string, data) {
+  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'html';
+  if (typeof string === 'string') {
+    return string.replace(/(\/)?\{\{([\s\S]*?)}}/g, function (match) {
+      var slash = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      var offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+      var sign = offset.substr(0, 1);
+      var hasSign = true;
+      var format = formatTypes.html;
+      var ret = getFormat({
+        sign: sign,
+        format: format,
+        hasSign: hasSign
+      });
+      format = ret.format;
+      hasSign = ret.hasSign;
+      if (hasSign) {
+        offset = (offset || '').substring(1);
+      } else if (type) {
+        format = type;
+      }
+      var value = getObj(data, offset);
+      if (isNull(value)) {
+        value = '';
+      }
+      if (format === formatTypes.tmpl) {
+        value = "{{".concat(value, "}}");
+      } else {
+        if (format === formatTypes.url) {
+          value = encodeURIComponent(value);
+        } else {
+          value = format === formatTypes.html ? escapeHtml(value) : value;
+        }
+      }
+      return format === formatTypes.url && value.length === 0 ? '' : slash + value;
+    });
+  }
+};
+var getFormatText = function getFormatText() {
+  return function (str, reg, args, format) {
+    return str.replace(reg, function (m, i, j, k) {
+      if (!isNullOrEmpty(i) && !isNullOrEmpty(k)) {
+        return "{".concat(j, "}");
+      }
+      var value = args[j];
+      var string = isPlainObject(value) ? toJsonStr(value) : value;
+      if (isNullOrEmpty(value)) {
+        return '';
+      }
+      return typeof value === 'string' && typeof format === 'function' ? format(string) : string;
+    });
+  };
+};
+var getResult = function getResult(_ref2) {
+  var type = _ref2.type,
+    res = _ref2.res,
+    formatText = _ref2.formatText,
+    string = _ref2.string,
+    reg = _ref2.reg,
+    args = _ref2.args;
+  if (type === formatTypes.url) {
+    res = formatText(string, reg, args, encodeURIComponent);
+  } else if (type === formatTypes.html) {
+    res = formatText(string, reg, args, escapeHtml);
+  } else {
+    res = formatText(string, reg, args);
+  }
+  return res;
+};
+var judgForFunc = function judgForFunc(args, formatTypes, type) {
+  var lastArg = args[args.length - 1];
+  if (lastArg !== formatTypes.text && lastArg !== formatTypes.url && lastArg !== formatTypes.html) {
+    args = Array.prototype.slice.call(args, 1);
+  } else {
+    args = Array.prototype.slice.call(args, 1, args.length - 1);
+    type = lastArg;
+  }
+  return {
+    args: args,
+    type: type
+  };
+};
+var checkParam = function checkParam(_ref3) {
+  var data = _ref3.data,
+    args = _ref3.args,
+    type = _ref3.type,
+    _arguments = _ref3._arguments;
+  if (Array.isArray(data)) {
+    args = data;
+  } else {
+    var judgObj = judgForFunc(_arguments, formatTypes, type);
+    args = judgObj.args;
+    type = judgObj.type;
+  }
+  return {
+    args: args,
+    type: type
+  };
+};
+export var format = function format(string, data) {
+  var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'text';
+  if (typeof string !== 'string' || arguments.length < 2) {
+    return string;
+  }
+  var args, res;
+  if (isPlainObject(data)) {
+    return fieldFormat(string, data, type);
+  }
+  var ret = checkParam({
+    data: data,
+    args: args,
+    type: type,
+    _arguments: arguments
+  });
+  args = ret.args;
+  type = ret.type;
+  var reg = /(\\)?\{(\d+)(\\)?}/g;
+  var formatText = getFormatText();
+  res = getResult({
+    type: type,
+    res: res,
+    formatText: formatText,
+    string: string,
+    reg: reg,
+    args: args
+  });
+  return res;
+};
+var getTruthyValue = function getTruthyValue(_ref4) {
+  var string = _ref4.string,
+    length = _ref4.length,
+    ellipsis = _ref4.ellipsis;
+  var flag = typeof string === 'string' && isNumber(length) && length < string.length;
+  var truthyValue = flag && format(ellipsis, string.substr(0, length));
+  return {
+    flag: flag,
+    truthyValue: truthyValue
+  };
+};
+export var truncate = function truncate(string, length) {
+  var ellipsis = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '{0}...';
+  var _getTruthyValue = getTruthyValue({
+      string: string,
+      length: length,
+      ellipsis: ellipsis
+    }),
+    flag = _getTruthyValue.flag,
+    truthyValue = _getTruthyValue.truthyValue;
+  return flag ? truthyValue : string;
+};
+export var tryToConvert = function tryToConvert(convert, defaultValue) {
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+  var result = convert.apply(null, args);
+  return isNaN(result) ? defaultValue : result;
+};
+export var toInt = function toInt(value) {
+  return isNumber(value) ? Number(value.toFixed(0)) : typeof value === 'string' ? parseInt(value, 10) : NaN;
+};
+export var tryToInt = function tryToInt(value, defaultValue) {
+  return tryToConvert(toInt, defaultValue, value);
+};
+export var toNumber = function toNumber(value) {
+  return isNumber(value) ? value : typeof value === 'string' ? parseFloat(value) : NaN;
+};
+export var tryToNumber = function tryToNumber(value, defaultValue) {
+  return tryToConvert(toNumber, defaultValue, value);
+};
+export var toDecimal = function toDecimal(value) {
+  var fraction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+  var isTruncate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var result = NaN;
+  if (isNumber(value)) {
+    result = value;
+  }
+  if (typeof value === 'string') {
+    var val = parseFloat(value);
+    if (!isNaN(val)) {
+      result = val;
+    }
+  }
+  if (isNumber(result)) {
+    if (isTruncate) {
+      result = toFixed(value.toString().split('.').slice(0, 2).map(function (str, index) {
+        return index ? str.slice(0, fraction) : str;
+      }).join('.'), fraction);
+    } else {
+      result = toFixed(result, fraction);
+    }
+  }
+  return result;
+};
+export var tryToDecimal = function tryToDecimal(value, fraction, isTruncate, defaultValue) {
+  return tryToConvert(toDecimal, defaultValue, value, fraction, isTruncate);
+};
+export var toCurrency = function toCurrency(value, fraction, placeholder, isTruncate) {
+  if (isNumeric(value)) {
+    var val = toDecimal(Number(value), fraction, isTruncate);
+    val = String(val).replace(/(^|[^\w.])(\d{4,})/g, function ($0, $1, $2) {
+      return $1 + $2.replace(/\d(?=(?:\d\d\d)+(?!\d))/g, '$&,');
+    });
+    return placeholder ? format(placeholder, val) : val;
+  }
+  return NaN;
+};
+export var tryToCurrency = function tryToCurrency(value, fraction, placeholder, defaultValue) {
+  return isNaN(toNumber(value)) ? defaultValue : toCurrency(value, fraction, placeholder);
+};
+export var toBoolValue = function toBoolValue(value) {
+  if (isNumber(value)) {
+    return value ? 1 : 0;
+  } else if (isNull(value) || value === 'false') {
+    return false;
+  } else if (value === 'true') {
+    return true;
+  } else if (typeof value === 'boolean') {
+    return value;
+  }
+  return !!value;
+};
+export var toRate = function toRate(value) {
+  var total = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  var fraction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 2;
+  return isNumber(value) && isNumber(total) ? "".concat(toDecimal(value * 100 / total, fraction), "%") : value;
+};
+export var toFileSize = function toFileSize(value, unit, currUnit) {
+  if (isNumeric(value)) {
+    value = Number(value);
+    if (value === 0) {
+      return "0".concat(currUnit || unit || 'B');
+    }
+    var fileSize = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+    var index = fileSize.indexOf(currUnit);
+    if (index > -1) {
+      for (var i = 0; i < index; i++) {
+        value *= 1024;
+      }
+    }
+    index = fileSize.indexOf(unit);
+    if (index < 0) {
+      index = fileSize.length - 1;
+    }
+    var level = 0;
+    for (var _i = 0; _i < index && (value <= -1024 || value >= 1024); _i++) {
+      value /= 1024.0;
+      level++;
+    }
+    return toDecimal(value, 2) + fileSize[level];
+  }
+  return value;
+};
+export var isKorean = function isKorean(text) {
+  return /([(\uAC00-\uD7AF)|(\u3130-\u318F)])+/gi.test(text);
+};

package/common/type.js

@@ -0,0 +1,65 @@
+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]') {
+    return false;
+  }
+  var proto = getProto(obj);
+  if (!proto) {
+    return true;
+  }
+  var 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) {
+      if (hasOwn.call(obj, name)) {
+        return false;
+      }
+    }
+  }
+  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);
+};
+export var isRegExp = function isRegExp(value) {
+  return typeOf(value) === 'regExp';
+};

package/common/validate/index.js

@@ -0,0 +1,6 @@
+import Schema from './schema';
+import validators from './validations/index';
+import getDefaultMessage from './messages';
+Schema.validators = validators;
+Schema.getDefaultMessage = getDefaultMessage;
+export default Schema;

package/common/validate/messages.js

@@ -0,0 +1,68 @@
+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')
+  };
+};
+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

@@ -0,0 +1,8 @@
+import * as util from '../util';
+var ENUM = 'enum';
+export default function (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(', ')));
+  }
+}

package/common/validate/rules/index.js

@@ -0,0 +1,14 @@
+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
+};

package/common/validate/rules/pattern.js

@@ -0,0 +1,16 @@
+import * as util from '../util';
+export default function (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);
+      if (!_pattern.test(checkValue)) {
+        errors.push(util.format(options.messages.pattern.mismatch, rule.fullField, checkValue, rule.pattern));
+      }
+    }
+  }
+}

package/common/validate/rules/range.js

@@ -0,0 +1,62 @@
+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;
+  if (min && !max && val < rule.min) {
+    errors.push(util.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));
+  } else if (min && max && (val < rule.min || val > rule.max)) {
+    errors.push(util.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);
+  if (num) {
+    key = 'number';
+  } else if (str) {
+    key = 'string';
+  } else if (arr) {
+    key = 'array';
+  }
+  if (!key) {
+    return false;
+  }
+  if (arr) {
+    val = checkValue.length;
+  }
+  if (str) {
+    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
+    });
+  }
+}