@opentiny/vue-renderless 3.1.0-alpha.0

package/common/validate/validations/date.js

@@ -0,0 +1,35 @@
+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';
+  };
+  if (validate) {
+    if (isEmptyValue(checkValue) && !rule.required) {
+      return callback();
+    }
+    rules.required({
+      rule: rule,
+      checkValue: checkValue,
+      source: source,
+      errors: errors,
+      options: options
+    });
+    if (!isEmptyValue(checkValue)) {
+      var 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') {
+        rules.range(rule, dateObject.getTime(), source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+}

package/common/validate/validations/enum.js

@@ -0,0 +1,24 @@
+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);
+  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[ENUM](rule, checkValue, source, errors, options);
+    }
+  }
+  callback(errors);
+}

package/common/validate/validations/float.js

@@ -0,0 +1,24 @@
+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);
+  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.type(rule, checkValue, source, errors, options);
+      rules.range(rule, checkValue, source, errors, options);
+    }
+  }
+  cb(errors);
+}

package/common/validate/validations/index.js

@@ -0,0 +1,42 @@
+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,
+  hex: type,
+  url: type,
+  time: type,
+  email: type,
+  digits: type,
+  dateYM: type,
+  speczh: type,
+  dateYMD: type,
+  version: type,
+  fileSize: type,
+  regexp: method,
+  object: method,
+  dateTime: type,
+  specialch: type,
+  "boolean": method,
+  acceptImg: type,
+  specialch2: type,
+  acceptFile: type,
+  longDateTime: type,
+  "enum": enumValidator
+};

package/common/validate/validations/integer.js

@@ -0,0 +1,24 @@
+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);
+  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.type(rule, checkValue, source, errors, options);
+      rules.range(rule, checkValue, source, errors, options);
+    }
+  }
+  callback(errors);
+}

package/common/validate/validations/method.js

@@ -0,0 +1,23 @@
+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 = [];
+  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.type(rule, checkValue, source, errors, options);
+    }
+  }
+  callback(errors);
+}

package/common/validate/validations/number.js

@@ -0,0 +1,27 @@
+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);
+  if (validate) {
+    if (checkValue === '') {
+      checkValue = undefined;
+    }
+    if (!rule.required && isEmptyValue(checkValue)) {
+      return callback();
+    }
+    rules.required({
+      rule: rule,
+      checkValue: checkValue,
+      source: source,
+      errors: errors,
+      options: options
+    });
+    if (checkValue !== undefined) {
+      rules.type(rule, checkValue, source, errors, options);
+      rules.range(rule, checkValue, source, errors, options);
+    }
+  }
+  callback(errors);
+}

package/common/validate/validations/pattern.js

@@ -0,0 +1,23 @@
+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);
+  if (validate) {
+    if (isEmptyValue(checkValue, 'string') && !rule.required) {
+      return callback();
+    }
+    rules.required({
+      rule: rule,
+      checkValue: checkValue,
+      source: source,
+      errors: errors,
+      options: options
+    });
+    if (!isEmptyValue(checkValue, 'string')) {
+      rules.pattern(rule, checkValue, source, errors, options);
+    }
+  }
+  callback(errors);
+}

package/common/validate/validations/required.js

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

package/common/validate/validations/string.js

@@ -0,0 +1,29 @@
+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);
+  if (validate) {
+    if (isEmptyValue(checkValue, 'string') && !rule.required) {
+      return callback();
+    }
+    rules.required({
+      rule: rule,
+      checkValue: checkValue,
+      source: source,
+      errors: errors,
+      options: options,
+      type: 'string'
+    });
+    if (!isEmptyValue(checkValue, 'string')) {
+      rules.type(rule, checkValue, source, errors, options);
+      rules.range(rule, checkValue, source, errors, options);
+      rules.pattern(rule, checkValue, source, errors, options);
+      if (rule.whitespace === true) {
+        rules.whitespace(rule, checkValue, source, errors, options);
+      }
+    }
+  }
+  callback(errors);
+}

package/common/validate/validations/type.js

@@ -0,0 +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 ruleType = rule.type;
+  var errors = [];
+  var validate = rule.required || !rule.required && hasOwn.call(source, rule.field);
+  if (validate) {
+    if (isEmptyValue(checkValue, ruleType) && !rule.required) {
+      return callback();
+    }
+    rules.required({
+      rule: rule,
+      checkValue: checkValue,
+      source: source,
+      errors: errors,
+      options: options,
+      type: ruleType
+    });
+    if (!isEmptyValue(checkValue, ruleType)) {
+      rules.type(rule, checkValue, source, errors, options);
+    }
+  }
+  callback(errors);
+}

package/common/xss.js

@@ -0,0 +1,325 @@
+import * as xss$1 from 'xss';
+var getWindow = function getWindow() {
+  return typeof window === 'undefined' ? global : window;
+};
+var isWeb = function isWeb() {
+  return !(typeof window === 'undefined');
+};
+var _win$2 = getWindow();
+var reverseUrlAlphabet = 'tcirzywvqlkjhgfbZQG_FLOWHSUBDNIMYREVKCAJxp57XP043891T62-modnaesu';
+var urlAlphabet$1 = reverseUrlAlphabet.split('').reverse().join('');
+var buffer;
+var bufferOffset;
+var allocBuffer = function allocBuffer(bytes) {
+  return new Uint8Array(new ArrayBuffer(bytes));
+};
+var randomFill = function randomFill(buffer) {
+  return _win$2.crypto.getRandomValues(buffer);
+};
+var defFillPool = function defFillPool(bytes) {
+  if (!buffer || buffer.length < bytes) {
+    buffer = allocBuffer(bytes * 128);
+    randomFill(buffer);
+    bufferOffset = 0;
+  } else if (bufferOffset + bytes > buffer.length) {
+    randomFill(buffer);
+    bufferOffset = 0;
+  }
+  bufferOffset += bytes;
+};
+var nanoid$2 = function nanoid$2(size) {
+  if (size === void 0) {
+    size = 21;
+  }
+  defFillPool(size -= 0);
+  var uniq = '';
+  for (var i = bufferOffset - size; i < bufferOffset; i++) {
+    uniq += urlAlphabet$1[buffer[i] & 63];
+  }
+  return uniq;
+};
+var defRandomFunc = function defRandomFunc(bytes) {
+  defFillPool(bytes -= 0);
+  return buffer.subarray(bufferOffset - bytes, bufferOffset);
+};
+var defCustomRandom = function defCustomRandom(alphabet, defaultSize, randomFunc) {
+  var mask = (2 << 31 - Math.clz32(alphabet.length - 1 | 1)) - 1;
+  var step = Math.ceil(1.6 * mask * defaultSize / alphabet.length);
+  return function (size) {
+    if (size === void 0) {
+      size = defaultSize;
+    }
+    var uniq = '';
+    var bytes = randomFunc(step);
+    var i = step;
+    while (i--) {
+      uniq += alphabet[bytes[i] & mask] || '';
+      if (uniq.length === size) {
+        return uniq;
+      }
+    }
+  };
+};
+var customAlphabet$1 = function customAlphabet$1(alphabet, defaultSize) {
+  if (defaultSize === void 0) {
+    defaultSize = 21;
+  }
+  return defCustomRandom(alphabet, defaultSize, defRandomFunc);
+};
+function isIE(window) {
+  return isWeb() && (window.document.all || window.document.documentMode) && !window.crypto && window.msCrypto;
+}
+function initForIE(window) {
+  if (isIE(window)) {
+    window.crypto = window.msCrypto;
+    var getRandomValuesDef = window.crypto.getRandomValues;
+    window.crypto.getRandomValues = function (array) {
+      var values = getRandomValuesDef.call(window.crypto, array);
+      var result = [];
+      for (var i = 0; i < array.length; i++) {
+        result[i] = values[i];
+      }
+      return result;
+    };
+  }
+}
+var _win$1 = getWindow();
+initForIE(_win$1);
+var MAX_UINT32_PLUS_ONE = 4294967296;
+var urlAlphabet = urlAlphabet$1;
+var nanoid$1 = nanoid$2;
+var customAlphabet = customAlphabet$1;
+var random = function random() {
+  if (!isWeb()) {
+    return 0;
+  }
+  return _win$1.crypto.getRandomValues(new _win$1.Uint32Array(1))[0] / MAX_UINT32_PLUS_ONE;
+};
+var api = {
+  urlAlphabet: urlAlphabet,
+  nanoid: nanoid$1,
+  customAlphabet: customAlphabet
+};
+var _nanoid = Object.freeze({
+  __proto__: null,
+  random: random,
+  api: api,
+  'default': api
+});
+var xssOptions = {
+  enableAttrs: true,
+  enableHtml: true,
+  enableUrl: true,
+  html: {
+    whiteList: {
+      a: ['class', 'style', 'contenteditable', 'data-id', 'data-title', 'data-size', 'data-last-modified'],
+      address: ['class', 'style'],
+      area: ['class', 'style'],
+      article: ['class', 'style'],
+      aside: ['class', 'style'],
+      audio: ['class', 'style'],
+      b: ['class', 'style'],
+      bdi: ['class', 'style'],
+      bdo: ['class', 'style'],
+      big: ['class', 'style'],
+      blockquote: ['class', 'style'],
+      br: ['class', 'style'],
+      caption: ['class', 'style'],
+      center: ['class', 'style'],
+      cite: ['class', 'style'],
+      code: ['class', 'style'],
+      col: ['class', 'style'],
+      colgroup: ['class', 'style'],
+      dd: ['class', 'style'],
+      del: ['class', 'style'],
+      details: ['class', 'style'],
+      div: ['class', 'style', 'spellcheck', 'data-gramm', 'spellcheck', 'data-mode', 'data-position', 'data-row', 'data-cell', 'data-rowspan', 'data-colspan', 'data-cell-bg', 'data-parent-bg'],
+      dl: ['class', 'style'],
+      dt: ['class', 'style'],
+      em: ['class', 'style'],
+      figcaption: ['class', 'style'],
+      figure: ['class', 'style'],
+      font: ['class', 'style'],
+      footer: ['class', 'style'],
+      h1: ['class', 'style'],
+      h2: ['class', 'style'],
+      h3: ['class', 'style'],
+      h4: ['class', 'style'],
+      h5: ['class', 'style'],
+      h6: ['class', 'style'],
+      header: ['class', 'style'],
+      hr: ['class', 'style'],
+      i: ['class', 'style', 'data-image-id', 'data-image'],
+      img: ['class', 'style', 'devui-editorx-image', 'style', 'data-image-id'],
+      input: ['class', 'style', 'data-formula', 'data-link', 'data-video'],
+      ins: ['class', 'style'],
+      li: ['class', 'style'],
+      mark: ['class', 'style'],
+      nav: ['class', 'style'],
+      ol: ['class', 'style'],
+      p: ['class', 'style'],
+      pre: ['class', 'style'],
+      s: ['class', 'style'],
+      section: ['class', 'style'],
+      small: ['class', 'style'],
+      span: ['class', 'style', 'contenteditable', 'color', 'style'],
+      sub: ['class', 'style'],
+      summary: ['class', 'style'],
+      sup: ['class', 'style'],
+      strong: ['class', 'style'],
+      strike: ['class', 'style'],
+      svg: ['class', 'style', 't', 'viewBox', 'version', 'xmlns', 'p-id', 'xmlns:xlink'],
+      path: ['d', 'p-id'],
+      table: ['class', 'style'],
+      tbody: ['class', 'style'],
+      td: ['class', 'style', 'data-row', 'data-cell', 'data-cell-bg', 'data-parent-bg'],
+      tfoot: ['class', 'style'],
+      th: ['class', 'style'],
+      thead: ['class', 'style'],
+      tr: ['class', 'style', 'data-row'],
+      tt: ['class', 'style'],
+      u: ['class', 'style'],
+      ul: ['class', 'style'],
+      video: ['class', 'style']
+    }
+  }
+};
+var defaultWhiteList = xss$1.getDefaultWhiteList && xss$1.getDefaultWhiteList() || {};
+xssOptions.html.whiteList = Object.assign(defaultWhiteList, xssOptions.html.whiteList);
+var xssFilterHtml = new xss$1.FilterXSS(xssOptions.html);
+var getXssOption = function getXssOption() {
+  return xssOptions;
+};
+var setXssOption = function setXssOption(option) {
+  var _a;
+  var whiteList;
+  if ((_a = option === null || option === void 0 ? void 0 : option.html) === null || _a === void 0 ? void 0 : _a.whiteList) {
+    whiteList = Object.assign(xssOptions.html.whiteList, option.html.whiteList);
+  }
+  xssOptions = Object.assign(xssOptions, option);
+  if (whiteList) {
+    xssOptions.html.whiteList = whiteList;
+  }
+  xssFilterHtml = new xss$1.FilterXSS(xssOptions.html);
+};
+var filterHtml = function filterHtml(content) {
+  if (!xssOptions.enableHtml || typeof content !== 'string') {
+    return content;
+  }
+  return xssFilterHtml.process(content);
+};
+var setFilterHtml = function setFilterHtml(filter) {
+  filterHtml = filter;
+};
+var filterAttrs = function filterAttrs(content) {
+  if (!xssOptions.enableAttrs || typeof content !== 'string') {
+    return content;
+  }
+  return content.replace(/<.*?>/gi, '').replace(/on[a-z]+=/gi, '');
+};
+var setFilterAttrs = function setFilterAttrs(filter) {
+  filterAttrs = filter;
+};
+var filterUrl = function filterUrl(content) {
+  if (!xssOptions.enableUrl || typeof content !== 'string') {
+    return content;
+  }
+  var filteredUrl = content.replace(/&#(\w+)(^\w|;)?/g, function (match, dec) {
+    return String.fromCharCode(dec);
+  }).trim();
+  if (!filteredUrl) {
+    return '';
+  }
+  if (['.', '/'].indexOf(filteredUrl[0]) > -1) {
+    return filteredUrl;
+  }
+  var urlParse = filteredUrl.match(/^([^:]+):/gm);
+  if (!urlParse) {
+    return filteredUrl;
+  }
+  if (/^([^\w]*)(javascript|data|vbscript)/im.test(urlParse[0])) {
+    return '';
+  }
+  return filteredUrl;
+};
+var setFilterUrl = function setFilterUrl(filter) {
+  filterUrl = filter;
+};
+var index = {
+  getXssOption: getXssOption,
+  setXssOption: setXssOption,
+  filterHtml: filterHtml,
+  setFilterHtml: setFilterHtml,
+  filterAttrs: filterAttrs,
+  setFilterAttrs: setFilterAttrs,
+  filterUrl: filterUrl,
+  setFilterUrl: setFilterUrl
+};
+var _xss = Object.freeze({
+  __proto__: null,
+  getXssOption: getXssOption,
+  setXssOption: setXssOption,
+  get filterHtml() {
+    return filterHtml;
+  },
+  setFilterHtml: setFilterHtml,
+  get filterAttrs() {
+    return filterAttrs;
+  },
+  setFilterAttrs: setFilterAttrs,
+  get filterUrl() {
+    return filterUrl;
+  },
+  setFilterUrl: setFilterUrl,
+  'default': index
+});
+var _win = getWindow();
+var _cnsl = 'console';
+var _console = _win[_cnsl] || {};
+var isOpen = true;
+var _print = {};
+var _log = function _log(csl, type) {
+  return function () {
+    var args = [];
+    for (var i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    if (!isOpen) {
+      return;
+    }
+    if (csl[type] && typeof csl[type] === 'function') {
+      csl[type].apply(csl, args);
+    }
+  };
+};
+var _initPrint = function _initPrint(csl) {
+  Object.keys(csl).forEach(function (type) {
+    _print[type] = _log(csl, type);
+  });
+  return _print;
+};
+var switchLogger = function switchLogger(flag) {
+  isOpen = !!flag;
+};
+var setLogger = function setLogger(type, fn) {
+  if (_print && Object.hasOwnProperty.call(_print, type)) {
+    _print[type] = fn;
+  }
+};
+var logger = _initPrint(_console);
+var _logger = Object.freeze({
+  __proto__: null,
+  switchLogger: switchLogger,
+  setLogger: setLogger,
+  logger: logger,
+  'default': logger
+});
+var def = {
+  nanoid: _nanoid,
+  xss: _xss,
+  log: _logger
+};
+var nanoid = _nanoid;
+var xss = _xss;
+var log = _logger;
+export { def as default, log, nanoid, xss };