@opentiny/vue-renderless 3.1.0-alpha.0

package/common/bigInt.js

@@ -0,0 +1,352 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { fillChar } from '@opentiny/vue-renderless/common/string';
+var BigInt = window.BigInt;
+export function supportBigInt() {
+  return typeof BigInt === 'function';
+}
+export function trimNumber(numStr) {
+  var string = numStr.toString().trim();
+  var negative = string.startsWith('-');
+  if (negative) {
+    string = string.slice(1);
+  }
+  string = string.replace(/(\.\d*[^0])0*$/, '$1').replace(/\.0*$/, '').replace(/^0+/, '');
+  if (string.startsWith('.')) {
+    string = '0'.concat(string);
+  }
+  var trimStr = string || '0';
+  var splitNumber = trimStr.split('.');
+  var integerStr = splitNumber[0] || '0';
+  var decimalStr = splitNumber[1] || '0';
+  if (integerStr === '0' && decimalStr === '0') {
+    negative = false;
+  }
+  var negativeStr = negative ? '-' : '';
+  return {
+    negative: negative,
+    negativeStr: negativeStr,
+    trimStr: trimStr,
+    integerStr: integerStr,
+    decimalStr: decimalStr,
+    fullStr: ''.concat(negativeStr).concat(trimStr)
+  };
+}
+export function isE(number) {
+  var str = String(number);
+  return !isNaN(Number(str)) && ~str.indexOf('e');
+}
+export function validateNumber(num) {
+  if (typeof num === 'number') {
+    return !isNaN(num);
+  }
+  if (!num) {
+    return false;
+  }
+  return /^\s*-?\d+(\.\d+)?\s*$/.test(num) || /^\s*-?\d+\.\s*$/.test(num) || /^\s*-?\.\d+\s*$/.test(num);
+}
+export function getNumberPrecision(number) {
+  var numStr = String(number);
+  if (isE(number)) {
+    var precision = Number(numStr.slice(numStr.indexOf('e-') + 2));
+    var decimalMatch = numStr.match(/\.(\d+)/);
+    if (decimalMatch === null || decimalMatch === void 0 ? void 0 : decimalMatch[1]) {
+      precision += decimalMatch[1].length;
+    }
+    return precision;
+  }
+  return ~numStr.indexOf('.') && validateNumber(numStr) ? numStr.length - numStr.indexOf('.') - 1 : 0;
+}
+export function num2str(number) {
+  var numStr = String(number);
+  if (isE(number)) {
+    if (number > Number.MAX_SAFE_INTEGER) {
+      return String(supportBigInt() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER);
+    }
+    if (number < Number.MIN_SAFE_INTEGER) {
+      return String(supportBigInt() ? BigInt(number).toString() : Number.MIN_SAFE_INTEGER);
+    }
+    numStr = number.toFixed(getNumberPrecision(numStr));
+  }
+  return trimNumber(numStr).fullStr;
+}
+function pluginDecimal(decimal) {
+  if (!decimal.add) {
+    Object.assign(decimal, {
+      add: decimal.plus,
+      lessEquals: decimal.isLessThan,
+      equals: decimal.isEqualTo
+    });
+  }
+  return decimal;
+}
+var DecimalCls = {
+  CLS: null
+};
+var setDecimalClass;
+export function getMiniDecimal(value, decimal) {
+  if (!DecimalCls.CLS) {
+    setDecimalClass(decimal);
+  }
+  return pluginDecimal(new DecimalCls.CLS(value));
+}
+export var BigIntDecimal = function () {
+  function BigIntDecimal(value) {
+    _classCallCheck(this, BigIntDecimal);
+    if (!value && value !== 0 || !String(value).trim()) {
+      this.empty = true;
+      return;
+    }
+    this.origin = String(value);
+    this.negative = void 0;
+    this.integer = void 0;
+    this.decimal = void 0;
+    this.decimalLen = void 0;
+    this.empty = void 0;
+    this.nan = void 0;
+    if (value === '-') {
+      this.nan = true;
+      return;
+    }
+    var mergedValue = isE(value) ? Number(value) : value;
+    if (typeof mergedValue !== 'string') {
+      num2str(mergedValue);
+    }
+    if (validateNumber(mergedValue)) {
+      var trimRet = trimNumber(mergedValue);
+      this.negative = trimRet.negative;
+      var numbers = trimRet.trimStr.split('.');
+      this.integer = BigInt(numbers[0]);
+      var decimalStr = numbers[1] || '0';
+      this.decimalLen = decimalStr.length;
+      this.decimal = BigInt(decimalStr);
+    } else {
+      this.nan = true;
+    }
+  }
+  _createClass(BigIntDecimal, [{
+    key: "getDecimalStr",
+    value: function getDecimalStr() {
+      return this.decimal.toString().padStart(this.decimalLen, '0');
+    }
+  }, {
+    key: "getIntegerStr",
+    value: function getIntegerStr() {
+      return this.integer.toString();
+    }
+  }, {
+    key: "getMark",
+    value: function getMark() {
+      return this.negative ? '-' : '';
+    }
+  }, {
+    key: "alignDecimal",
+    value: function alignDecimal(decimalLength) {
+      var string = "".concat(this.getMark()).concat(this.getIntegerStr()).concat(this.getDecimalStr().padEnd(decimalLength, '0'));
+      return BigInt(string);
+    }
+  }, {
+    key: "add",
+    value: function add(value) {
+      if (this.isInvalidate()) {
+        return new BigIntDecimal(value);
+      }
+      var offsetObj = new BigIntDecimal(value);
+      if (offsetObj.isInvalidate()) {
+        return this;
+      }
+      var maxDecimalLength = Math.max(this.getDecimalStr().length, offsetObj.getDecimalStr().length);
+      var offsetAlignedDecimal = offsetObj.alignDecimal(maxDecimalLength);
+      var myAlignedDecimal = this.alignDecimal(maxDecimalLength);
+      var valueStr = "".concat(myAlignedDecimal + offsetAlignedDecimal);
+      var _trimNumber = trimNumber(valueStr),
+        str = _trimNumber.negativeStr,
+        trimStr = _trimNumber.trimStr;
+      var hydrateValueStr = "".concat(str).concat(trimStr.padStart(maxDecimalLength + 1, '0'));
+      return getMiniDecimal("".concat(hydrateValueStr.slice(0, -maxDecimalLength), ".").concat(hydrateValueStr.slice(-maxDecimalLength)));
+    }
+  }, {
+    key: "negate",
+    value: function negate() {
+      var clone = new BigIntDecimal(this.toString());
+      clone.negative = !clone.negative;
+      return clone;
+    }
+  }, {
+    key: "isNaN",
+    value: function isNaN() {
+      return this.nan;
+    }
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return this.empty;
+    }
+  }, {
+    key: "isInvalidate",
+    value: function isInvalidate() {
+      return this.isEmpty() || this.isNaN();
+    }
+  }, {
+    key: "lessEquals",
+    value: function lessEquals(target) {
+      return this.add(target.negate().toString()).toNumber() <= 0;
+    }
+  }, {
+    key: "equals",
+    value: function equals(target) {
+      return this.toString() === (target && target.toString());
+    }
+  }, {
+    key: "toNumber",
+    value: function toNumber() {
+      if (this.isNaN()) {
+        return NaN;
+      }
+      return Number(this.toString());
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      var safe = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      if (!safe) {
+        return this.origin;
+      }
+      if (this.isInvalidate()) {
+        return '';
+      }
+      return trimNumber("".concat(this.getMark()).concat(this.getIntegerStr(), ".").concat(this.getDecimalStr())).fullStr;
+    }
+  }]);
+  return BigIntDecimal;
+}();
+export var NumberDecimal = function () {
+  function NumberDecimal() {
+    var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    _classCallCheck(this, NumberDecimal);
+    if (!value && value !== 0 || !String(value).trim()) {
+      this.empty = true;
+      return;
+    }
+    this.origin = '';
+    this.number = void 0;
+    this.empty = void 0;
+    this.origin = String(value);
+    this.number = Number(value);
+  }
+  _createClass(NumberDecimal, [{
+    key: "negate",
+    value: function negate() {
+      return new NumberDecimal(-this.toNumber());
+    }
+  }, {
+    key: "add",
+    value: function add(value) {
+      if (this.isInvalidate()) {
+        return new NumberDecimal(value);
+      }
+      var target = Number(value);
+      if (isNaN(target)) {
+        return this;
+      }
+      var number = this.number + target;
+      if (number < Number.MIN_SAFE_INTEGER) {
+        return new NumberDecimal(Number.MIN_SAFE_INTEGER);
+      }
+      if (number > Number.MAX_SAFE_INTEGER) {
+        return new NumberDecimal(Number.MAX_SAFE_INTEGER);
+      }
+      var maxPrecision = Math.max(getNumberPrecision(target), getNumberPrecision(this.number));
+      return new NumberDecimal(number.toFixed(maxPrecision));
+    }
+  }, {
+    key: "isNaN",
+    value: function (_isNaN) {
+      function isNaN() {
+        return _isNaN.apply(this, arguments);
+      }
+      isNaN.toString = function () {
+        return _isNaN.toString();
+      };
+      return isNaN;
+    }(function () {
+      return isNaN(this.number);
+    })
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return this.empty;
+    }
+  }, {
+    key: "isInvalidate",
+    value: function isInvalidate() {
+      return this.isEmpty() || this.isNaN();
+    }
+  }, {
+    key: "equals",
+    value: function equals(target) {
+      return this.toNumber() === (target && target.toNumber());
+    }
+  }, {
+    key: "lessEquals",
+    value: function lessEquals(target) {
+      return this.add(target.negate().toString()).toNumber() <= 0;
+    }
+  }, {
+    key: "toNumber",
+    value: function toNumber() {
+      return this.number;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      var safe = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      if (!safe) {
+        return this.origin;
+      }
+      if (this.isInvalidate()) {
+        return '';
+      }
+      return num2str(this.number);
+    }
+  }]);
+  return NumberDecimal;
+}();
+setDecimalClass = function setDecimalClass(decimaljs) {
+  DecimalCls.CLS = supportBigInt() ? BigIntDecimal : typeof decimaljs === 'function' ? decimaljs : NumberDecimal;
+};
+export { setDecimalClass };
+export function lessEquals(value1, value2) {
+  return getMiniDecimal(value1).lessEquals(getMiniDecimal(value2));
+}
+export function equalsDecimal(value1, value2) {
+  return getMiniDecimal(value1).equals(getMiniDecimal(value2));
+}
+export function toFixed(numStr, precision) {
+  var rounding = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 5;
+  if (numStr === '') {
+    return '';
+  }
+  var separatorStr = '.';
+  var _trimNumber2 = trimNumber(numStr),
+    negativeStr = _trimNumber2.negativeStr,
+    integerStr = _trimNumber2.integerStr,
+    decimalStr = _trimNumber2.decimalStr;
+  var precisionDecimalStr = "".concat(separatorStr).concat(decimalStr);
+  var numberWithoutDecimal = "".concat(negativeStr).concat(integerStr);
+  if (precision >= 0) {
+    var advancedNum = Number(decimalStr[precision]);
+    if (advancedNum >= rounding && rounding !== 0) {
+      var advancedDecimal = getMiniDecimal("".concat(integerStr).concat(separatorStr).concat(decimalStr)).add("0.".concat(fillChar('', precision, true)).concat(10 - advancedNum));
+      return toFixed(negativeStr + advancedDecimal.toString(), precision, 0);
+    }
+    if (precision === 0) {
+      return numberWithoutDecimal;
+    }
+    return "".concat(numberWithoutDecimal).concat(separatorStr).concat(fillChar(decimalStr, precision, true).slice(0, precision));
+  }
+  if (precisionDecimalStr === '.0') {
+    return numberWithoutDecimal;
+  }
+  return "".concat(numberWithoutDecimal).concat(precisionDecimalStr);
+}

package/common/browser.js

@@ -0,0 +1,69 @@
+var getIEVersion = function getIEVersion() {
+  var version = 8;
+  if (!!document.addEventListener && !!window.performance) {
+    version = 9;
+    if (!!window.atob && !!window.matchMedia) {
+      version = 10;
+      if (!window.attachEvent && !document.all) {
+        version = 11;
+      }
+    }
+  }
+  return version;
+};
+var isEdge = function isEdge(browser) {
+  if (browser.chrome && ~navigator.userAgent.indexOf('Edg')) {
+    browser.name = 'edge';
+    browser.edge = true;
+    delete browser.chrome;
+  } else if (!document.documentMode && !!window.StyleMedia) {
+    browser.name = 'edge';
+    browser.edge = true;
+  }
+};
+export default (function () {
+  var isMobile = /(Android|webOS|iPhone|iPad|iPod|SymbianOS|BlackBerry|Windows Phone)/.test(navigator.userAgent);
+  var browser = {
+    name: undefined,
+    version: undefined,
+    isDoc: typeof document !== 'undefined',
+    isMobile: isMobile,
+    isPC: !isMobile,
+    isNode: typeof window === 'undefined'
+  };
+  var matches;
+  if (!!window.chrome && (!!window.chrome.webstore || /^Google\b/.test(window.navigator.vendor))) {
+    browser.name = 'chrome';
+    browser.chrome = true;
+    matches = navigator.userAgent.match(/chrome\/(\d+)/i);
+    browser.version = !!matches && !!matches[1] && parseInt(matches[1], 10);
+    matches = undefined;
+  } else if (!!document.all || !!document.documentMode) {
+    browser.name = 'ie';
+    browser.version = getIEVersion();
+    browser.ie = true;
+  } else if (typeof window.InstallTrigger !== 'undefined') {
+    browser.name = 'firefox';
+    browser.firefox = true;
+  } else if (Object.prototype.toString.call(window.HTMLElement).indexOf('Constructor') > 0) {
+    browser.name = 'safari';
+    browser.safari = true;
+  } else if (!!window.opr && !!window.opr.addons || !!window.opera) {
+    browser.name = 'opera';
+    browser.opera = true;
+  }
+  isEdge(browser);
+  if (!~['ie', 'chrome'].indexOf(browser.name)) {
+    var reg = browser.name + '/(\\d+)';
+    matches = navigator.userAgent.match(new RegExp(reg, 'i'));
+    browser.version = !!matches && !!matches[1] && parseInt(matches[1], 10);
+    matches = undefined;
+  }
+  if (browser.isDoc) {
+    var bodyEl = document.body || document.documentElement;
+    ['webkit', 'khtml', 'moz', 'ms', 'o'].forEach(function (core) {
+      browser['-' + core] = !!bodyEl[core + 'MatchesSelector'];
+    });
+  }
+  return browser;
+})();

package/common/dataset/index.js

@@ -0,0 +1,135 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+var _excluded = ["type", "data", "beforeRequest", "afterRequest", "success", "hideErr", "url", "method"];
+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 } from '@opentiny/vue-renderless/common/string';
+import { isObject } from '@opentiny/vue-renderless/common/type';
+import { transformTreeData } from '@opentiny/vue-renderless/common/array';
+var getFilterStr = function getFilterStr(filters) {
+  var filterArr = {};
+  Object.keys(filters).forEach(function (property) {
+    var _filters$property = filters[property],
+      type = _filters$property.type,
+      value = _filters$property.value;
+    if (type === 'enum') {
+      filterArr[property] = {
+        type: value.map(function () {
+          return 0;
+        }),
+        value: value
+      };
+      if (value.length > 1) {
+        filters[property].relation = 'or';
+      }
+    }
+    if (type === 'input') {
+      var relation = value.relation,
+        text = value.text;
+      filterArr[property] = {
+        type: [relation === 'startwith' ? 8 : relation === 'equals' ? 0 : 6],
+        value: text
+      };
+    }
+  });
+  return JSON.stringify(filterArr);
+};
+var getNsObj = function getNsObj(obj, names) {
+  var arr = Array.isArray(names) ? names : names.split('.');
+  var curkey = arr.shift();
+  var curObj = obj[curkey];
+  if (isObject(curObj) && arr.length) {
+    return getNsObj(curObj, arr);
+  }
+  return curObj;
+};
+var handlerArgs = function handlerArgs(options, args) {
+  if (args) {
+    var page = args.page,
+      sort = args.sort,
+      filters = args.filters;
+    var _ref = page || {},
+      currentPage = _ref.currentPage,
+      pageSize = _ref.pageSize;
+    var filterStr = getFilterStr(filters || {});
+    var orderBy = sort && sort.property ? sort.property + ' ' + sort.order : '';
+    options.url = format(options.url, {
+      curPage: currentPage,
+      pageSize: pageSize,
+      filterStr: filterStr,
+      orderBy: orderBy
+    });
+  }
+};
+var transForm = function transForm(response, tree) {
+  var result = response.result,
+    pageVO = response.pageVO;
+  var _ref2 = tree || {},
+    _ref2$key = _ref2.key,
+    key = _ref2$key === void 0 ? 'id' : _ref2$key,
+    parentKey = _ref2.parentKey;
+  var data = result || response;
+  if (parentKey) {
+    data = transformTreeData(data, key, parentKey);
+  }
+  return pageVO ? {
+    result: data,
+    page: {
+      total: pageVO.totalRows
+    }
+  } : data;
+};
+export var getDataset = function getDataset(_ref3, args) {
+  var dataset = _ref3.dataset,
+    service = _ref3.service,
+    tree = _ref3.tree;
+  return new Promise(function (resolve, reject) {
+    var _ref4 = dataset || {},
+      source = _ref4.source,
+      value = _ref4.value,
+      api = _ref4.api;
+    var $service = service || dataset && dataset.service;
+    if (Array.isArray(dataset)) {
+      return resolve(transForm(dataset, tree));
+    }
+    if (Array.isArray(value)) {
+      return resolve(transForm(value, tree));
+    }
+    if (!$service) {
+      return resolve([]);
+    }
+    if (isObject(source) && source.url) {
+      var _source$type = source.type,
+        type = _source$type === void 0 ? 'GET' : _source$type,
+        data = source.data,
+        beforeRequest = source.beforeRequest,
+        afterRequest = source.afterRequest,
+        success = source.success,
+        hideErr = source.hideErr,
+        url = source.url,
+        method = source.method,
+        options = _objectWithoutProperties(source, _excluded);
+      options.url = url;
+      options.method = method || type.toLocaleLowerCase();
+      var mergeTarget = options.method === 'get' ? 'params' : 'data';
+      options[mergeTarget] = data || {};
+      var afterRequestFn = afterRequest || success;
+      var config = _objectSpread({}, options);
+      handlerArgs(config, args);
+      beforeRequest && beforeRequest(config, args);
+      $service.network.request(config).then(function (response) {
+        afterRequestFn && afterRequestFn(response.data);
+        resolve(transForm(response.data, tree));
+      })["catch"](function (error) {
+        hideErr || reject(error);
+      });
+    } else if (api) {
+      var fetchFn = getNsObj($service, api.name);
+      fetchFn && fetchFn(_objectSpread(_objectSpread({}, api.data), args)).then(function (response) {
+        resolve(transForm(response, tree));
+      })["catch"](function (error) {
+        reject(error);
+      });
+    }
+  });
+};